feat: support multi agent for ts

.changeset/yellow-jokes-protect.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+Add multi agents template for Express

helpers/typescript.ts

@@ -33,7 +33,11 @@ export const installTSTemplate = async ({
    * Copy the template files to the target directory.
    */
   console.log("\nInitializing project with template:", template, "\n");
-  const type = template === "multiagent" ? "streaming" : template; // use nextjs streaming template for multiagent
+  let type = "streaming";
+  if (template === "multiagent" && framework === "express") {
+    // use nextjs streaming template as frontend for express and fastapi
+    type = "multiagent";
+  }
   const templatePath = path.join(templatesDir, "types", type, framework);
   const copySource = ["**"];
 
@@ -124,6 +128,13 @@ export const installTSTemplate = async ({
     cwd: path.join(compPath, "vectordbs", "typescript", vectorDb ?? "none"),
   });
 
+  if (template === "multiagent") {
+    await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
+      parents: true,
+      cwd: path.join(compPath, "multiagent", "typescript", "workflow"),
+    });
+  }
+
   // copy loader component (TS only supports llama_parse and file for now)
   const loaderFolder = useLlamaParse ? "llama_parse" : "file";
   await copy("**", enginePath, {
@@ -145,6 +156,11 @@ export const installTSTemplate = async ({
     cwd: path.join(compPath, "engines", "typescript", engine),
   });
 
+  // copy settings to engine folder
+  await copy("**", enginePath, {
+    cwd: path.join(compPath, "settings", "typescript"),
+  });
+
   /**
    * Copy the selected UI files to the target directory and reference it.
    */

questions.ts

@@ -410,10 +410,7 @@ export const askQuestions = async (
     return; // early return - no further questions needed for llamapack projects
   }
 
-  if (program.template === "multiagent") {
-    // TODO: multi-agents currently only supports FastAPI
-    program.framework = preferences.framework = "fastapi";
-  } else if (program.template === "extractor") {
+  if (program.template === "extractor") {
     // Extractor template only supports FastAPI, empty data sources, and llamacloud
     // So we just use example file for extractor template, this allows user to choose vector database later
     program.dataSources = [EXAMPLE_FILE];
@@ -424,7 +421,9 @@ export const askQuestions = async (
       program.framework = getPrefOrDefault("framework");
     } else {
       const choices = [
-        { title: "NextJS", value: "nextjs" },
+        ...(program.template === "multiagent"
+          ? []
+          : [{ title: "NextJS", value: "nextjs" }]), // Not supported nextjs for multiagent for now
         { title: "Express", value: "express" },
         { title: "FastAPI (Python)", value: "fastapi" },
       ];

templates/components/multiagent/typescript/workflow/agents.ts

@@ -0,0 +1,62 @@
+import { StreamData } from "ai";
+import { ChatMessage, QueryEngineTool } from "llamaindex";
+import { getDataSource } from "../engine";
+import { FunctionCallingAgent } from "./factory";
+
+const getQueryEngineTool = async () => {
+  const index = await getDataSource();
+  if (!index) {
+    throw new Error("Index not found. Please create an index first.");
+  }
+
+  const topK = process.env.TOP_K ? parseInt(process.env.TOP_K) : undefined;
+  return new QueryEngineTool({
+    queryEngine: index.asQueryEngine({
+      similarityTopK: topK,
+    }),
+    metadata: {
+      name: "query_index",
+      description: `Use this tool to retrieve information about the text corpus from the index.`,
+    },
+  });
+};
+
+export const createResearcher = async (
+  chatHistory: ChatMessage[],
+  stream: StreamData,
+) => {
+  return new FunctionCallingAgent({
+    name: "researcher",
+    tools: [await getQueryEngineTool()],
+    systemPrompt:
+      "You are a researcher agent. You are given a researching task. You must use your tools to complete the research.",
+    chatHistory,
+    stream,
+  });
+};
+
+export const createWriter = (
+  chatHistory: ChatMessage[],
+  stream: StreamData,
+) => {
+  return new FunctionCallingAgent({
+    name: "writer",
+    systemPrompt:
+      "You are an expert in writing blog posts. You are given a task to write a blog post. Don't make up any information yourself.",
+    chatHistory,
+    stream,
+  });
+};
+
+export const createReviewer = (
+  chatHistory: ChatMessage[],
+  stream: StreamData,
+) => {
+  return new FunctionCallingAgent({
+    name: "reviewer",
+    systemPrompt:
+      "You are an expert in reviewing blog posts. You are given a task to review a blog post. Review the post for logical inconsistencies, ask critical questions, and provide suggestions for improvement. Furthermore, proofread the post for grammar and spelling errors. Only if the post is good enough for publishing, then you MUST return 'The post is good.'. In all other cases return your review.",
+    chatHistory,
+    stream,
+  });
+};

templates/components/multiagent/typescript/workflow/factory.ts

@@ -0,0 +1,152 @@
+import {
+  Context,
+  StartEvent,
+  StopEvent,
+  Workflow,
+  WorkflowEvent,
+} from "@llamaindex/core/workflow";
+import { StreamData } from "ai";
+import {
+  BaseToolWithCall,
+  CallbackManager,
+  ChatMemoryBuffer,
+  ChatMessage,
+  EngineResponse,
+  LLM,
+  OpenAIAgent,
+  Settings,
+} from "llamaindex";
+import { AgentInput, FunctionCallingStreamResult } from "./type";
+
+class InputEvent extends WorkflowEvent<{
+  input: ChatMessage[];
+}> {}
+
+export class FunctionCallingAgent extends Workflow {
+  name: string;
+  llm: LLM;
+  memory: ChatMemoryBuffer;
+  tools: BaseToolWithCall[];
+  systemPrompt?: string;
+  writeEvents: boolean;
+  role?: string;
+  callbackManager: CallbackManager;
+  stream: StreamData;
+
+  constructor(options: {
+    name: string;
+    llm?: LLM;
+    chatHistory?: ChatMessage[];
+    tools?: BaseToolWithCall[];
+    systemPrompt?: string;
+    writeEvents?: boolean;
+    role?: string;
+    verbose?: boolean;
+    timeout?: number;
+    stream: StreamData;
+  }) {
+    super({
+      verbose: options?.verbose ?? false,
+      timeout: options?.timeout ?? 360,
+    });
+    this.name = options?.name;
+    this.llm = options.llm ?? Settings.llm;
+    this.memory = new ChatMemoryBuffer({
+      llm: this.llm,
+      chatHistory: options.chatHistory,
+    });
+    this.tools = options?.tools ?? [];
+    this.systemPrompt = options.systemPrompt;
+    this.writeEvents = options?.writeEvents ?? true;
+    this.role = options?.role;
+    this.callbackManager = this.createCallbackManager();
+    this.stream = options.stream;
+
+    // add steps
+    this.addStep(StartEvent<AgentInput>, this.prepareChatHistory, {
+      outputs: InputEvent,
+    });
+    this.addStep(InputEvent, this.handleLLMInput, {
+      outputs: StopEvent,
+    });
+  }
+
+  private get chatHistory() {
+    return this.memory.getAllMessages();
+  }
+
+  private async prepareChatHistory(
+    ctx: Context,
+    ev: StartEvent<AgentInput>,
+  ): Promise<InputEvent> {
+    const { message, streaming } = ev.data.input;
+    ctx.set("streaming", streaming);
+    this.writeEvent(`Start to work on: ${message}`);
+    if (this.systemPrompt) {
+      this.memory.put({ role: "system", content: this.systemPrompt });
+    }
+    this.memory.put({ role: "user", content: message });
+    return new InputEvent({ input: this.chatHistory });
+  }
+
+  private async handleLLMInput(
+    ctx: Context,
+    ev: InputEvent,
+  ): Promise<StopEvent<string | ReadableStream<EngineResponse>>> {
+    const chatEngine = new OpenAIAgent({
+      tools: this.tools,
+      systemPrompt: this.systemPrompt,
+      chatHistory: this.chatHistory,
+    });
+
+    if (!ctx.get("streaming")) {
+      const response = await Settings.withCallbackManager(
+        this.callbackManager,
+        () => {
+          return chatEngine.chat({
+            message: ev.data.input.pop()!.content,
+          });
+        },
+      );
+      this.writeEvent("Finished task");
+      return new StopEvent({ result: response.message.content.toString() });
+    }
+
+    const response = await Settings.withCallbackManager(
+      this.callbackManager,
+      () => {
+        return chatEngine.chat({
+          message: ev.data.input.pop()!.content,
+          stream: true,
+        });
+      },
+    );
+    ctx.writeEventToStream({ data: new FunctionCallingStreamResult(response) });
+    return new StopEvent({ result: response });
+  }
+
+  private createCallbackManager() {
+    const callbackManager = new CallbackManager();
+    callbackManager.on("llm-tool-call", (event) => {
+      const { toolCall } = event.detail;
+      this.writeEvent(
+        `Calling tool "${toolCall.name}" with input: ${JSON.stringify(toolCall.input)}`,
+      );
+    });
+    callbackManager.on("llm-tool-result", (event) => {
+      const { toolCall, toolResult } = event.detail;
+      this.writeEvent(
+        `Getting result from tool "${toolCall.name}": \n${JSON.stringify(toolResult.output)}`,
+      );
+    });
+    return callbackManager;
+  }
+
+  private writeEvent(msg: string) {
+    if (!this.writeEvents) return;
+    this.stream.appendMessageAnnotation({
+      type: "agent",
+      data: { agent: this.name, text: msg },
+    });
+  }
+}