@agenite/agent

A simple and maintainable TypeScript library for building AI agents with tool integration capabilities.

Features

🛠️ Tool Integration - Easily integrate custom tools and APIs
🔄 Stateful Conversations - Maintain conversation history and context
🌊 Streaming Support - Real-time streaming of agent responses
🎯 Execution Context - Track and manage nested agent executions
🔌 Provider Agnostic - Support for multiple LLM providers (Ollama, Bedrock)
🎨 Flexible Architecture - Build simple to complex agent hierarchies

Installation

npm install @agenite/agent

Quick Start

import { Agent } from '@agenite/agent';
import { OllamaProvider } from '@agenite/ollama';

// Create a simple calculator tool
const calculatorTool = new Tool({
  name: 'calculator',
  description: 'Perform basic math operations',
  execute: async ({ input }) => {
    // Tool implementation
    return { success: true, data: result.toString() };
  },
});

// Initialize the agent
const agent = new Agent({
  name: 'math-buddy',
  provider: new OllamaProvider({ model: 'llama2' }),
  tools: [calculatorTool],
  systemPrompt: 'You are a helpful math assistant.',
});

// Execute the agent
const result = await agent.execute({
  input: 'What is 1234 * 5678?',
  stream: true, // Enable streaming
});

Core Concepts

Agent

The main class that orchestrates interactions between the LLM and tools. It handles:

Message processing
Tool execution
Response streaming
State management

Tools

Tools are functions that agents can use to perform specific tasks. Each tool has:

Name and description
Input schema
Execute function
Version information

Providers

LLM providers that handle the actual language model interactions:

Ollama
Amazon Bedrock
Extensible for other providers

Advanced Usage

Stateful Agent

Maintain conversation history and state across multiple interactions:

const agent = new Agent({
  name: 'stateful-calculator',
  provider,
  tools: [calculatorTool],
  systemPrompt: `You are a helpful math assistant that maintains a running total.`,
});

let messages = [];
const result = await agent.execute({
  input: [...messages, { role: 'user', content: query }],
  stream: true,
});
messages = result.messages;

Nested Agents

Create hierarchical agent structures where agents can delegate tasks:

// Specialist agents
const calculatorAgent = new Agent({
  name: 'calculator-specialist',
  provider,
  tools: [calculatorTool],
});

const weatherAgent = new Agent({
  name: 'weather-specialist',
  provider,
  tools: [weatherTool],
});

// Coordinator agent
const coordinatorAgent = new Agent({
  name: 'coordinator',
  provider,
  tools: [
    createDelegateTool('askCalculator', calculatorAgent),
    createDelegateTool('askWeather', weatherAgent),
  ],
});

Streaming Responses

Process agent responses in real-time:

const iterator = agent.iterate({
  input: 'Your query here',
  stream: true,
});

for await (const chunk of iterator) {
  switch (chunk.type) {
    case 'streaming':
      console.log(chunk.response.text);
      break;
    case 'toolUse':
      console.log('Using tool:', chunk.tools[0]?.tool);
      break;
    // Handle other chunk types
  }
}

API Reference

Agent Constructor

new Agent({
  name: string;
  provider: LLMProvider;
  tools?: Tool[];
  systemPrompt?: string;
})

Execute Method

execute({
  input: string | BaseMessage[];
  stream?: boolean;
  context?: ExecutionContext;
}): Promise<ExecutionResult>

Iterate Method

iterate({
  input: string | BaseMessage[];
  stream?: boolean;
  context?: ExecutionContext;
}): AsyncIterator<StreamChunk>

Examples

Check out the examples directory for more detailed examples:

basic/ - Simple examples showing core functionality
- simple-chat.ts - Basic chat agent with calculator tool
advanced/ - More complex examples
- nested-agents.ts - Agent composition and delegation
- stateful-agent.ts - Maintaining conversation state
- streaming-agent.ts - Real-time response streaming
- multi-tool-agent.ts - Using multiple tools

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT