@librechat/agents 3.0.0-rc1 → 3.0.0-rc11

package/src/scripts/multi-agent-chain.ts

@@ -0,0 +1,278 @@
+import { config } from 'dotenv';
+config();
+
+import {
+  HumanMessage,
+  BaseMessage,
+  getBufferString,
+} from '@langchain/core/messages';
+import { Run } from '@/run';
+import { Providers, GraphEvents } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+/**
+ * Helper function to create sequential chain edges with buffer string prompts
+ *
+ * @param agentIds - Array of agent IDs in order of execution
+ * @returns Array of edges configured for sequential chain with buffer prompts
+ */
+function createSequentialChainEdges(agentIds: string[]): t.GraphEdge[] {
+  const edges: t.GraphEdge[] = [];
+
+  for (let i = 0; i < agentIds.length - 1; i++) {
+    const fromAgent = agentIds[i];
+    const toAgent = agentIds[i + 1];
+
+    edges.push({
+      from: fromAgent,
+      to: toAgent,
+      edgeType: 'direct',
+      // Use a prompt function to create the buffer string from all previous results
+      prompt: (messages: BaseMessage[], startIndex: number) => {
+        // Get only the messages from this run (after startIndex)
+        const runMessages = messages.slice(startIndex);
+
+        // Create buffer string from run messages
+        const bufferString = getBufferString(runMessages);
+
+        // Format the prompt for the next agent
+        return `Based on the following conversation and analysis from previous agents, please provide your insights:\n\n${bufferString}\n\nPlease add your specific expertise and perspective to this discussion.`;
+      },
+      // Critical: exclude previous results so only the prompt is passed
+      excludeResults: true,
+      description: `Sequential chain from ${fromAgent} to ${toAgent}`,
+    });
+  }
+
+  return edges;
+}
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of sequential agent chain mimicking the old chain behavior
+ *
+ * Graph structure:
+ * START -> researcher -> analyst -> reviewer -> summarizer -> END
+ *
+ * Each agent receives a buffer string of all previous results
+ */
+async function testSequentialAgentChain() {
+  console.log('Testing Sequential Agent Chain (Old Chain Pattern)...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define four agents with specific roles
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'researcher',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Research Agent specializing in gathering initial information.
+      Your role is to:
+      1. Identify key aspects of the user's query
+      2. List important factors to consider
+      3. Provide initial research findings
+      
+      Format your response with clear sections and bullet points.
+      Start with "RESEARCH FINDINGS:" and be thorough but concise.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'analyst',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are an Analysis Agent that builds upon research findings.
+      Your role is to:
+      1. Analyze the research provided by the previous agent
+      2. Identify patterns, risks, and opportunities
+      3. Provide deeper analytical insights
+      
+      Start with "ANALYSIS:" and structure your response with clear categories.
+      Reference specific points from the research when relevant.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'reviewer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Critical Review Agent that evaluates the work done so far.
+      Your role is to:
+      1. Review the research and analysis from previous agents
+      2. Identify any gaps or areas that need more attention
+      3. Suggest improvements or additional considerations
+      
+      Start with "CRITICAL REVIEW:" and be constructive in your feedback.
+      Highlight both strengths and areas for improvement.`,
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'summarizer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Summary Agent that creates the final comprehensive output.
+      Your role is to:
+      1. Synthesize all insights from the researcher, analyst, and reviewer
+      2. Create a cohesive, actionable summary
+      3. Provide clear recommendations or conclusions
+      
+      Start with "EXECUTIVE SUMMARY:" followed by key sections.
+      End with "KEY RECOMMENDATIONS:" or "CONCLUSIONS:" as appropriate.`,
+      maxContextTokens: 8000,
+    },
+  ];
+
+  // Create sequential chain edges using our helper function
+  const agentIds = agents.map((a) => a.agentId);
+  const edges = createSequentialChainEdges(agentIds);
+
+  // Track agent progression
+  let currentAgent = '';
+
+  // Create custom handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          currentAgent = runStepData.name;
+          console.log(`\n→ ${currentAgent} is processing...`);
+        }
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          console.log(`✓ ${runStepData.name} completed`);
+        }
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.RunStepDeltaEvent });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({ event, data: data as t.MessageDeltaEvent });
+      },
+    },
+  };
+
+  // Create multi-agent run configuration
+  const runConfig: t.RunConfig = {
+    runId: `sequential-chain-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    // Create and execute the run
+    const run = await Run.create(runConfig);
+
+    // Test with a complex question that benefits from multiple perspectives
+    const userMessage =
+      'I want to launch a new mobile app for personal finance management. What should I consider?';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    console.log(`User: "${userMessage}"\n`);
+    console.log('Starting sequential agent chain...\n');
+
+    const config = {
+      configurable: {
+        thread_id: 'sequential-chain-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    // Process with streaming
+    const inputs = {
+      messages: conversationHistory,
+    };
+
+    const finalContentParts = await run.processStream(inputs, config);
+    const finalMessages = run.getRunMessages();
+
+    if (finalMessages) {
+      conversationHistory.push(...finalMessages);
+    }
+
+    console.log('\n\n=== Final Output ===');
+    console.log('Sequential chain completed successfully!');
+    console.log(`Total content parts: ${contentParts.length}`);
+
+    // Display the buffer accumulation
+    console.log('\n=== Agent Outputs (Buffer Accumulation) ===');
+
+    const aiMessages = conversationHistory.filter(
+      (msg) => msg._getType() === 'ai'
+    );
+
+    aiMessages.forEach((msg, index) => {
+      console.log(`\n--- Agent ${index + 1}: ${agentIds[index]} ---`);
+      console.log(msg.content);
+
+      // Show buffer preview for next agent (except last)
+      if (index < aiMessages.length - 1) {
+        const bufferSoFar = getBufferString(aiMessages.slice(0, index + 1));
+        console.log(
+          `\n[Buffer passed to ${agentIds[index + 1]}]: ${bufferSoFar.slice(0, 150)}...`
+        );
+      }
+    });
+
+    // Demonstrate that each agent built upon previous results
+    console.log('\n=== Chain Analysis ===');
+    console.log('1. Researcher provided initial findings');
+    console.log('2. Analyst built upon research with deeper insights');
+    console.log('3. Reviewer critiqued and identified gaps');
+    console.log('4. Summarizer synthesized everything into actionable output');
+  } catch (error) {
+    console.error('Error in sequential agent chain test:', error);
+  }
+}
+
+// Run the test
+testSequentialAgentChain();

package/src/scripts/multi-agent-document-review-chain.ts

@@ -0,0 +1,197 @@
+import { config } from 'dotenv';
+config();
+
+import {
+  HumanMessage,
+  BaseMessage,
+  getBufferString,
+} from '@langchain/core/messages';
+import { Run } from '@/run';
+import { Providers, GraphEvents } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import type * as t from '@/types';
+
+/**
+ * Create edges for a document review chain where each agent adds their expertise
+ */
+function createDocumentReviewChain(agentIds: string[]): t.GraphEdge[] {
+  const edges: t.GraphEdge[] = [];
+
+  for (let i = 0; i < agentIds.length - 1; i++) {
+    edges.push({
+      from: agentIds[i],
+      to: agentIds[i + 1],
+      edgeType: 'direct',
+      prompt: (messages: BaseMessage[], startIndex: number) => {
+        const runMessages = messages.slice(startIndex);
+        const bufferString = getBufferString(runMessages);
+
+        // Custom prompt that maintains context of document review
+        return `You are reviewing a document. Here is the analysis so far from previous reviewers:\n\n${bufferString}\n\nPlease add your specific review based on your expertise. Build upon previous insights without repeating them.`;
+      },
+      excludeResults: true,
+    });
+  }
+
+  return edges;
+}
+
+async function testDocumentReviewChain() {
+  console.log('Testing Document Review Chain...\n');
+
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define specialized document reviewers
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'grammar_checker',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Grammar and Style Checker.
+      Focus on:
+      - Grammar errors
+      - Spelling mistakes
+      - Sentence structure
+      - Writing clarity
+      
+      Start with "GRAMMAR & STYLE CHECK:" and list issues found.`,
+      maxContextTokens: 4000,
+    },
+    {
+      agentId: 'fact_checker',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Fact Checker.
+      Focus on:
+      - Accuracy of claims
+      - Data verification needs
+      - Source requirements
+      - Logical consistency
+      
+      Start with "FACT CHECK:" and note any claims that need verification.`,
+      maxContextTokens: 4000,
+    },
+    {
+      agentId: 'tone_reviewer',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are a Tone and Audience Reviewer.
+      Focus on:
+      - Appropriate tone for target audience
+      - Consistency of voice
+      - Engagement level
+      - Cultural sensitivity
+      
+      Start with "TONE & AUDIENCE REVIEW:" and provide specific feedback.`,
+      maxContextTokens: 4000,
+    },
+    {
+      agentId: 'final_editor',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions: `You are the Final Editor.
+      Based on all previous reviews:
+      1. Summarize key issues found
+      2. Prioritize changes needed
+      3. Provide final recommendation (approve/revise/reject)
+      
+      Start with "FINAL EDITORIAL DECISION:" and be decisive.`,
+      maxContextTokens: 4000,
+    },
+  ];
+
+  const agentIds = agents.map((a) => a.agentId);
+  const edges = createDocumentReviewChain(agentIds);
+
+  // Custom handlers (simplified)
+  const customHandlers = {
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name) {
+          console.log(`\n✍️  ${runStepData.name} reviewing...`);
+        }
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+  };
+
+  const runConfig: t.RunConfig = {
+    runId: `doc-review-chain-${Date.now()}`,
+    graphConfig: {
+      type: 'multi-agent',
+      agents,
+      edges,
+    },
+    customHandlers,
+    returnContent: true,
+  };
+
+  try {
+    const run = await Run.create(runConfig);
+
+    // Sample document to review
+    const documentToReview = `
+    The Impact of Artificial Intelligence on Modern Business
+
+    Artificial Intelligence (AI) is revolutionizing how businesses operate in 2024. Studies show that 85% of companies have implemented some form of AI, leading to average productivity gains of 40%.
+
+    Key benefits includes:
+    - Automated decision-making reducing human error by 90%
+    - Cost savings of up to $1 billion annually for large corporations
+    - Enhanced customer experiences through 24/7 AI support
+
+    However, challenges remain. Many organizations struggles with data privacy concerns and the need for specialized talent. The future of AI in business looks bright, but companies must carefully navigate these obstacles to fully realize it's potential.
+    `;
+
+    const userMessage = `Please review this document:\n\n${documentToReview}`;
+    const messages = [new HumanMessage(userMessage)];
+
+    console.log('Document submitted for review...\n');
+
+    const config = {
+      configurable: { thread_id: 'doc-review-1' },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    await run.processStream({ messages }, config);
+
+    console.log('\n=== Review Chain Complete ===');
+
+    // Show how each reviewer built upon previous feedback
+    const runMessages = run.getRunMessages();
+    if (runMessages) {
+      console.log('\nReview progression:');
+      runMessages.forEach((msg, i) => {
+        if (msg._getType() === 'ai') {
+          console.log(`\nStep ${i + 1}: ${agentIds[Math.floor(i / 2)]}`);
+          console.log('---');
+          console.log(msg.content.toString().slice(0, 200) + '...');
+        }
+      });
+    }
+  } catch (error) {
+    console.error('Error in document review chain:', error);
+  }
+}
+
+// Run the test
+// testDocumentReviewChain();