Types d'Agents Avancés

import { ReActAgent } from '@orka-js/agent';
import { OpenAIAdapter } from '@orka-js/openai';
import type { Tool } from '@orka-js/tools';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
// Define tools
const searchTool: Tool = {
  name: 'web_search',
  description: 'Search the web for current information',
  parameters: [
    { name: 'query', type: 'string', description: 'Search query', required: true }
  ],
  execute: async (input) => {
    const results = await mySearchAPI(input.query as string);
    return { output: results };
  }
};
 
const calculatorTool: Tool = {
  name: 'calculator',
  description: 'Perform mathematical calculations',
  parameters: [
    { name: 'expression', type: 'string', description: 'Math expression to evaluate', required: true }
  ],
  execute: async (input) => {
    const result = eval(input.expression as string); // Use a safe math parser in production
    return { output: String(result) };
  }
};
 
// Create ReAct agent
const agent = new ReActAgent(
  {
    goal: 'Help users find information and perform calculations',
    tools: [searchTool, calculatorTool],
    maxSteps: 10,
    verbose: true,  // Logs each Thought/Action/Observation
    policy: {
      rules: [
        'Always verify information from multiple sources',
        'Show your calculations step by step'
      ]
    }
  },
  llm
);
 
const result = await agent.run('What is the population of France times 2?');
 
console.log(result.output);
// "The population of France is approximately 68 million. 68,000,000 × 2 = 136,000,000."
 
console.log(result.steps);
// [
//   { thought: "I need to find the population of France", action: "web_search", ... },
//   { thought: "Now I need to multiply by 2", action: "calculator", ... }
// ]

import { PlanAndExecuteAgent } from '@orka-js/agent';
 
const agent = new PlanAndExecuteAgent(
  {
    goal: 'Research and analyze data to answer complex questions',
    tools: [searchTool, calculatorTool, databaseTool],
    maxSteps: 15,
    replanOnFailure: true,  // Dynamically adjust plan if a step fails
  },
  llm
);
 
const result = await agent.run(
  'Compare the GDP per capita of France, Germany, and Japan. Which has grown the most in the last 5 years?'
);
 
console.log(result.output);
// Comprehensive comparison with data and analysis
 
console.log(result.plan);
// [
//   { id: 1, description: "Search for France GDP per capita data", status: "completed", result: "..." },
//   { id: 2, description: "Search for Germany GDP per capita data", status: "completed", result: "..." },
//   { id: 3, description: "Search for Japan GDP per capita data", status: "completed", result: "..." },
//   { id: 4, description: "Calculate growth rates for each country", status: "completed", result: "..." },
//   { id: 5, description: "Compare and determine highest growth", status: "completed", result: "..." }
// ]
 
console.log(result.steps);
// Detailed execution trace with timing and token usage per step

import { OpenAIFunctionsAgent } from '@orka-js/agent';
 
const agent = new OpenAIFunctionsAgent(
  {
    goal: 'Help users manage their tasks and calendar',
    tools: [
      {
        name: 'create_event',
        description: 'Create a calendar event',
        parameters: [
          { name: 'title', type: 'string', description: 'Event title', required: true },
          { name: 'date', type: 'string', description: 'Event date (YYYY-MM-DD)', required: true },
          { name: 'time', type: 'string', description: 'Event time (HH:MM)', required: false },
        ],
        execute: async (input) => {
          await calendarAPI.create(input);
          return { output: `Event "${input.title}" created for ${input.date}` };
        }
      },
      {
        name: 'list_events',
        description: 'List calendar events for a date range',
        parameters: [
          { name: 'start_date', type: 'string', description: 'Start date', required: true },
          { name: 'end_date', type: 'string', description: 'End date', required: true },
        ],
        execute: async (input) => {
          const events = await calendarAPI.list(input.start_date, input.end_date);
          return { output: JSON.stringify(events) };
        }
      }
    ],
    // Optional: provide custom function definitions (auto-generated from tools if omitted)
    // functions: [{ name: 'create_event', description: '...', parameters: { ... } }],
    maxSteps: 5,
  },
  llm
);
 
const result = await agent.run('Schedule a team meeting for next Monday at 2pm');
 
console.log(result.output);
// "I've created a 'Team Meeting' event for 2024-03-18 at 14:00."
 
console.log(result.metadata);
// { agentType: 'openai-functions', stepsUsed: 1 }

import { StructuredChatAgent } from '@orka-js/agent';
 
const agent = new StructuredChatAgent(
  {
    goal: 'Analyze customer support tickets and route them',
    tools: [
      {
        name: 'classify_ticket',
        description: 'Classify a support ticket by category and urgency',
        parameters: [
          { name: 'text', type: 'string', description: 'Ticket text', required: true }
        ],
        execute: async (input) => {
          // Classification logic
          return { output: JSON.stringify({ category: 'billing', urgency: 'high' }) };
        }
      },
      {
        name: 'route_ticket',
        description: 'Route a ticket to the appropriate team',
        parameters: [
          { name: 'category', type: 'string', description: 'Ticket category', required: true },
          { name: 'urgency', type: 'string', description: 'Urgency level', required: true }
        ],
        execute: async (input) => {
          return { output: `Routed to ${input.category} team (priority: ${input.urgency})` };
        }
      }
    ],
    // Optional: enforce output format
    outputSchema: {
      type: 'object',
      properties: {
        category: { type: 'string' },
        urgency: { type: 'string' },
        team: { type: 'string' },
        summary: { type: 'string' }
      }
    },
    maxSteps: 5,
  },
  llm
);
 
const result = await agent.run('Customer says: "I was charged twice for my subscription!"');
 
console.log(result.output);
// "Classified as billing/high urgency. Routed to billing team with priority handling."
 
console.log(result.steps);
// All steps are structured JSON — easy to log and audit

import { StreamingToolAgent } from '@orka-js/agent';
import { OpenAIAdapter } from '@orka-js/openai';
import { Memory } from '@orka-js/memory-store';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
 
const searchTool = {
  name: 'search_products',
  description: 'Search for products matching a query',
  parameters: [
    { name: 'query', type: 'string', description: 'Search query', required: true },
    { name: 'maxPrice', type: 'number', description: 'Maximum price filter', required: false },
  ],
  execute: async ({ query, maxPrice }) => {
    const results = await productDB.search(query as string, maxPrice as number);
    return { output: JSON.stringify(results) };
  },
};
 
// Optional: pass a Memory instance for conversation persistence
const memory = new Memory();
 
const agent = new StreamingToolAgent(
  {
    goal: 'Help customers find products that match their needs',
    tools: [searchTool],
    maxSteps: 5,
    verbose: true,       // Logs each tool call to console
  },
  llm,
  memory,               // Agent remembers context across requests
);
 
// ─── Streaming run ────────────────────────────────────────────────────────────
 
for await (const event of agent.runStream('Find me a Bluetooth headphone under 200€')) {
  switch (event.type) {
    case 'token':
      process.stdout.write(event.token);  // LLM thinking in real time
      break;
    case 'tool_call':
      console.log(`\n[→] ${event.name}(${event.arguments})`);
      break;
    case 'tool_result':
      console.log(`[←] ${event.result}`);  // Tool output before final answer
      break;
    case 'done':
      console.log('\n[✓]', event.content);
      break;
    case 'error':
      console.error('[✗]', event.message);
      break;
  }
}
 
// ─── Subsequent call — agent remembers the previous exchange ──────────────────
 
for await (const event of agent.runStream('What about under 150€?')) {
  // Agent knows the context: "Bluetooth headphone" from previous turn
  if (event.type === 'token') process.stdout.write(event.token);
}
 
// ─── Non-streaming shortcut ───────────────────────────────────────────────────
 
const result = await agent.run('Show me the top-rated option');
console.log(result.output);         // Final answer
console.log(result.steps);          // Tool calls with observations
console.log(result.totalTokens);    // Token usage

import { SQLToolkit, ReActAgent } from '@orka-js/agent';
 
const sqlToolkit = new SQLToolkit({
  execute: async (query: string) => {
    // Connect to your database
    const result = await db.query(query);
    return JSON.stringify(result.rows);
  },
  schema: `
    CREATE TABLE users(id INT, name VARCHAR, email VARCHAR, created_at TIMESTAMP);
    CREATE TABLE orders(id INT, user_id INT, amount DECIMAL, status VARCHAR, created_at TIMESTAMP);
    CREATE TABLE products(id INT, name VARCHAR, price DECIMAL, category VARCHAR);
  `,
  readOnly: true,   // Only SELECT queries allowed
  maxRows: 50       // Auto-inject LIMIT 50
});
 
// Use with any agent type
const agent = new ReActAgent(
  {
    goal: 'Answer questions about the database by writing SQL queries',
    tools: sqlToolkit.tools,  // Includes: sql_query, sql_schema, sql_list_tables
    maxSteps: 8,
  },
  llm
);
 
const result = await agent.run('How many orders were placed last month? What was the total revenue?');
 
// The agent will:
// 1. Use sql_schema to understand the tables
// 2. Write and execute SQL queries
// 3. Synthesize the results into a natural language answer

import { CSVToolkit, ReActAgent } from '@orka-js/agent';
 
const csvData = `name,department,salary,start_date
Alice,Engineering,95000,2021-03-15
Bob,Marketing,72000,2020-06-01
Charlie,Engineering,105000,2019-01-10
Diana,Sales,68000,2022-09-20
Eve,Engineering,88000,2023-02-01`;
 
const csvToolkit = new CSVToolkit({
  data: csvData,
  separator: ','  // default
});
 
const agent = new ReActAgent(
  {
    goal: 'Analyze employee data and answer questions',
    tools: csvToolkit.tools,  // Includes: csv_info, csv_search, csv_filter, csv_aggregate
    maxSteps: 8,
  },
  llm
);
 
// Ask questions about the data
const result = await agent.run('What is the average salary in Engineering? Who earns the most?');
 
// The agent will use csv_filter and csv_aggregate tools to find the answer
console.log(result.output);
// "The average salary in Engineering is $96,000. Charlie earns the most at $105,000."
 
// CSV Toolkit tools:
// - csv_info: Get column names, row count, sample data
// - csv_search: Search for rows by column value (partial match)
// - csv_filter: Filter rows with operators (=, !=, >, <, >=, <=, contains)
// - csv_aggregate: count, sum, avg, min, max, distinct

import { PlanAndExecuteAgent, SQLToolkit, CSVToolkit } from '@orka-js/agent';
 
const sqlToolkit = new SQLToolkit({ execute: db.query, readOnly: true });
const csvToolkit = new CSVToolkit({ data: reportCSV });
 
// Combine toolkit tools with custom tools
const allTools = [
  ...sqlToolkit.tools,
  ...csvToolkit.tools,
  myCustomSearchTool,
  myCalculatorTool,
];
 
const agent = new PlanAndExecuteAgent(
  {
    goal: 'Cross-reference database records with CSV reports',
    tools: allTools,
    maxSteps: 15,
    replanOnFailure: true,
  },
  llm
);
 
const result = await agent.run(
  'Compare the sales figures in the CSV report with the orders table in the database. Are there any discrepancies?'
);

// ✅ Import only what you need
import { ReActAgent } from '@orka-js/agent';
import { PlanAndExecuteAgent } from '@orka-js/agent';
import { OpenAIFunctionsAgent } from '@orka-js/agent';
import { StructuredChatAgent } from '@orka-js/agent';
import { StreamingToolAgent } from '@orka-js/agent';  // v1.5.0+
import { SQLToolkit, CSVToolkit } from '@orka-js/agent';
 
// ✅ Or combine in one import
import { ReActAgent, PlanAndExecuteAgent, StreamingToolAgent, SQLToolkit } from '@orka-js/agent';