@librechat/agents 2.4.322 → 3.0.0-rc10

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

@@ -0,0 +1,220 @@
+import { config } from 'dotenv';
+config();
+
+import { HumanMessage, BaseMessage } 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';
+
+const conversationHistory: BaseMessage[] = [];
+
+/**
+ * Example of conditional multi-agent system
+ *
+ * Graph structure:
+ * START -> classifier
+ * classifier -> technical_expert (if technical question)
+ * classifier -> business_expert (if business question)
+ * classifier -> general_assistant (otherwise)
+ * [all experts] -> END
+ */
+async function testConditionalMultiAgent() {
+  console.log('Testing Conditional Multi-Agent System...\n');
+
+  // Set up content aggregator
+  const { contentParts, aggregateContent } = createContentAggregator();
+
+  // Define specialized agents
+  const agents: t.AgentInputs[] = [
+    {
+      agentId: 'classifier',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a query classifier. Analyze user questions and determine if they are technical, business-related, or general.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'technical_expert',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a technical expert. Provide detailed technical answers about programming, systems, and technology.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'business_expert',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a business expert. Provide insights on business strategy, operations, and management.',
+      maxContextTokens: 8000,
+    },
+    {
+      agentId: 'general_assistant',
+      provider: Providers.ANTHROPIC,
+      clientOptions: {
+        modelName: 'claude-3-5-sonnet-latest',
+        apiKey: process.env.ANTHROPIC_API_KEY,
+      },
+      instructions:
+        'You are a helpful general assistant. Answer questions on a wide range of topics.',
+      maxContextTokens: 8000,
+    },
+  ];
+
+  // Define conditional edges
+  // These create handoff tools with conditional routing logic
+  const edges: t.GraphEdge[] = [
+    {
+      from: 'classifier',
+      to: ['technical_expert', 'business_expert', 'general_assistant'],
+      description: 'Route to appropriate expert based on query type',
+      condition: (state: t.BaseGraphState) => {
+        // Simple keyword-based routing for demo
+        // In a real system, this would use the classifier's analysis
+        const lastMessage = state.messages[state.messages.length - 1];
+        const content = lastMessage.content?.toString().toLowerCase() || '';
+
+        if (
+          content.includes('code') ||
+          content.includes('programming') ||
+          content.includes('technical')
+        ) {
+          return 'technical_expert';
+        } else if (
+          content.includes('business') ||
+          content.includes('strategy') ||
+          content.includes('market')
+        ) {
+          return 'business_expert';
+        } else {
+          return 'general_assistant';
+        }
+      },
+    },
+  ];
+
+  // Track selected expert
+  let selectedExpert = '';
+
+  // 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_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP,
+        data: t.StreamEventData
+      ): void => {
+        const runStepData = data as any;
+        if (runStepData?.name && runStepData.name !== 'classifier') {
+          selectedExpert = runStepData.name;
+          console.log(`Routing to: ${selectedExpert}`);
+        }
+        aggregateContent({ event, data: data as t.RunStep });
+      },
+    },
+    [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: `conditional-multi-agent-${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 different types of questions
+    const testQuestions = [
+      'How do I implement a binary search tree in Python?',
+      'What are the key strategies for market expansion?',
+      'What is the capital of France?',
+    ];
+
+    const config = {
+      configurable: {
+        thread_id: 'conditional-conversation-1',
+      },
+      streamMode: 'values',
+      version: 'v2' as const,
+    };
+
+    for (const question of testQuestions) {
+      console.log(`\n--- Processing: "${question}" ---\n`);
+
+      // Reset for each question
+      selectedExpert = '';
+      conversationHistory.length = 0;
+      conversationHistory.push(new HumanMessage(question));
+
+      // 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\nExpert used: ${selectedExpert}`);
+      console.log('Content parts:', contentParts.length);
+      console.log('---');
+    }
+  } catch (error) {
+    console.error('Error in conditional multi-agent test:', error);
+  }
+}
+
+// Run the test
+testConditionalMultiAgent();

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();