KaibanJS
The JavaScript Framework for Building Multi-agent Systems.
1. Install KaibanJS via npm:
```bash npm install kaibanjs ```2. Import KaibanJS in your JavaScript file:
```js // Using ES6 import syntax for NextJS, React, etc. import { Agent, Task, Team } from 'kaibanjs'; ``` ```js // Using CommonJS syntax for NodeJS const { Agent, Task, Team } = require('kaibanjs'); ```3. Basic Usage Example
```js // Define an agent const researchAgent = new Agent({ name: 'Researcher', role: 'Information Gatherer', goal: 'Find relevant information on a given topic', }); // Create a task const researchTask = new Task({ description: 'Research recent AI developments', agent: researchAgent, }); // Set up a team const team = new Team({ name: 'AI Research Team', agents: [researchAgent], tasks: [researchTask], env: { OPENAI_API_KEY: 'your-api-key-here' }, }); // Start the workflow team .start() .then((output) => { console.log('Workflow completed:', output.result); }) .catch((error) => { console.error('Workflow error:', error); }); ```The Kaiban Board
Kanban boards are excellent tools for showcasing team workflows in real time, providing a clear and interactive snapshot of each member's progress. > We’ve adapted this concept for AI agents. Now, you can visualize the workflow of your AI agents as team members, with tasks moving from "To Do" to "Done" right before your eyes. This visual representation simplifies understanding and managing complex AI operations, making it accessible to anyone, anywhere.Role-Based Agent Design
Harness the power of specialization by configuring AI agents to excel in distinct, critical functions within your projects. This approach enhances the effectiveness and efficiency of each task, moving beyond the limitations of generic AI. In this example, our software development team is powered by three specialized AI agents: Dave, Ella, and Quinn. Each agent is expertly tailored to its specific role, ensuring efficient task handling and synergy that accelerates the development cycle.
```js import { Agent } from 'kaibanjs'; const daveLoper = new Agent({ name: 'Dave Loper', role: 'Developer', goal: 'Write and review code', background: 'Experienced in JavaScript, React, and Node.js', }); const ella = new Agent({ name: 'Ella', role: 'Product Manager', goal: 'Define product vision and manage roadmap', background: 'Skilled in market analysis and product strategy', }); const quinn = new Agent({ name: 'Quinn', role: 'QA Specialist', goal: 'Ensure quality and consistency', background: 'Expert in testing, automation, and bug tracking', }); ```Tool Integration
Just as professionals use specific tools to excel in their tasks, enable your AI agents to utilize tools like search engines, calculators, and more to perform specialized tasks with greater precision and efficiency. In this example, one of the AI agents, Peter Atlas, leverages the Tavily Search Results tool to enhance his ability to select the best cities for travel. This tool allows Peter to analyze travel data considering weather, prices, and seasonality, ensuring the most suitable recommendations.
```js import { Agent, Tool } from 'kaibanjs'; const tavilySearchResults = new Tool({ name: 'Tavily Search Results', maxResults: 1, apiKey: 'ENV_TRAVILY_API_KEY', }); const peterAtlas = new Agent({ name: 'Peter Atlas', role: 'City Selector', goal: 'Choose the best city based on comprehensive travel data', background: 'Experienced in geographical data analysis and travel trends', tools: [tavilySearchResults], }); ``` _KaibanJS supports all LangchainJS-compatible tools, offering a versatile approach to tool integration. For further details, visit the [documentation](https://github.com/kaiban-ai/KaibanJS)._Multiple LLMs Support
Optimize your AI solutions by integrating a range of specialized AI models, each tailored to excel in distinct aspects of your projects. In this example, the agents—Emma, Lucas, and Mia—use diverse AI models to handle specific stages of feature specification development. This targeted use of AI models not only maximizes efficiency but also ensures that each task is aligned with the most cost-effective and appropriate AI resources.
```js import { Agent } from 'kaibanjs'; const emma = new Agent({ name: 'Emma', role: 'Initial Drafting', goal: 'Outline core functionalities', llmConfig: { provider: 'google', model: 'gemini-1.5-pro', }, }); const lucas = new Agent({ name: 'Lucas', role: 'Technical Specification', goal: 'Draft detailed technical specifications', llmConfig: { provider: 'anthropic', model: 'claude-3-5-sonnet-20240620', }, }); const mia = new Agent({ name: 'Mia', role: 'Final Review', goal: 'Ensure accuracy and completeness of the final document', llmConfig: { provider: 'openai', model: 'gpt-4o', }, }); ``` _For further details on integrating diverse AI models with KaibanJS, please visit the [documentation](https://github.com/kaiban-ai/KaibanJS)._Robust State Management
KaibanJS employs a Redux-inspired architecture, enabling a unified approach to manage the states of AI agents, tasks, and overall flow within your applications. This method ensures consistent state management across complex agent interactions, providing enhanced clarity and control. Here's a simplified example demonstrating how to integrate KaibanJS with state management in a React application:
```js import myAgentsTeam from './agenticTeam'; const KaibanJSComponent = () => { const useTeamStore = myAgentsTeam.useStore(); const { agents, workflowResult } = useTeamStore((state) => ({ agents: state.agents, workflowResult: state.workflowResult, })); return (Workflow Result: {workflowResult}
🕵️♂️ Agents
{agents.map((agent) => ({agent.name} - {agent.role} - Status: ({agent.status})
))}Integrate with Your Preferred JavaScript Frameworks
Easily add AI capabilities to your NextJS, React, Vue, Angular, and Node.js projects. KaibanJS is designed for seamless integration across a diverse range of JavaScript environments. Whether you’re enhancing user interfaces in React, Vue, or Angular, building scalable applications with NextJS, or implementing server-side solutions in Node.js, the framework integrates smoothly into your existing workflow.
```js import React from 'react'; import myAgentsTeam from './agenticTeam'; const TaskStatusComponent = () => { const useTeamStore = myAgentsTeam.useStore(); const { tasks } = useTeamStore((state) => ({ tasks: state.tasks.map((task) => ({ id: task.id, description: task.description, status: task.status, })), })); return (Task Statuses
-
{tasks.map((task) => (
- {task.description}: Status - {task.status} ))}
Observability and Monitoring
Built into KaibanJS, the observability features enable you to track every state change with detailed stats and logs, ensuring full transparency and control. This functionality provides real-time insights into token usage, operational costs, and state changes, enhancing system reliability and enabling informed decision-making through comprehensive data visibility. The following code snippet demonstrates how the state management approach is utilized to monitor and react to changes in workflow logs, providing granular control and deep insights into the operational dynamics of your AI agents:
```js const useStore = myAgentsTeam.useStore(); useStore.subscribe( (state) => state.workflowLogs, (newLogs, previousLogs) => { if (newLogs.length > previousLogs.length) { const { task, agent, metadata } = newLogs[newLogs.length - 1]; if (newLogs[newLogs.length - 1].logType === 'TaskStatusUpdate') { switch (task.status) { case TASK_STATUS_enum.DONE: console.log('Task Completed', { taskDescription: task.description, agentName: agent.name, agentModel: agent.llmConfig.model, duration: metadata.duration, llmUsageStats: metadata.llmUsageStats, costDetails: metadata.costDetails, }); break; case TASK_STATUS_enum.DOING: case TASK_STATUS_enum.BLOCKED: case TASK_STATUS_enum.REVISE: case TASK_STATUS_enum.TODO: console.log('Task Status Update', { taskDescription: task.description, taskStatus: task.status, agentName: agent.name, }); break; default: console.warn('Encountered an unexpected task status:', task.status); break; } } } } ); ``` For more details on how to utilize observability features in KaibanJS, please visit the [documentation](https://github.com/kaiban-ai/KaibanJS).