🤖 Agenite

A modern, modular, and type-safe framework for building AI agents using typescript

What is Agenite?

Agenite is a powerful TypeScript framework designed for building sophisticated AI agents. It provides a modular, type-safe, and flexible architecture that makes it easy to create, compose, and control AI agents with advanced capabilities.

✨ Key features

• Type safety and developer experience

  • Built from the ground up with TypeScript
  • Robust type checking for tools and agent configurations
  • Excellent IDE support and autocompletion

• Tool integration

  • First-class support for function calling
  • Built-in JSON Schema validation
  • Structured error handling
  • Easy API integration

• Provider agnostic

  • Support for OpenAI, Anthropic, AWS Bedrock, and Ollama
  • Consistent interface across providers
  • Easy extension for new providers

• Advanced architecture

  • Bidirectional flow using JavaScript generators
  • Step-based execution model
  • Built-in state management with reducers
  • Flexible middleware system

• Model context protocol (MCP)

  • Standardized protocol for connecting LLMs to data sources
  • Client implementation for interacting with MCP servers
  • Access to web content, filesystem, databases, and more

📦 Available packages

For a typical setup, you'll need the core packages and at least one provider:

# Install core packages
npm install @agenite/agent @agenite/tool @agenite/llm

# Install your preferred provider
npm install @agenite/openai
# OR
npm install @agenite/bedrock

🚀 Quick start

import { Agent } from '@agenite/agent';
import { Tool } from '@agenite/tool';
import { BedrockProvider } from '@agenite/bedrock';
import { prettyLogger } from '@agenite/pretty-logger';

// Create a calculator tool
const calculatorTool = new Tool<{ expression: string }>({
  name: 'calculator',
  description: 'Perform basic math operations',
  inputSchema: {
    type: 'object',
    properties: {
      expression: { type: 'string' },
    },
    required: ['expression'],
  },
  execute: async ({ input }) => {
    try {
      const result = new Function('return ' + input.expression)();
      return { isError: false, data: result.toString() };
    } catch (error) {
      if (error instanceof Error) {
        return { isError: true, data: error.message };
      }
      return { isError: true, data: 'Unknown error' };
    }
  },
});

// Create an agent
const agent = new Agent({
  name: 'math-buddy',
  provider: new BedrockProvider({
    model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
  }),
  tools: [calculatorTool],
  instructions: 'You are a helpful math assistant.',
  middlewares: [prettyLogger()],
});

// Example usage
const result = await agent.execute({
  messages: [
    {
      role: 'user',
      content: [{ type: 'text', text: 'What is 1234 * 5678?' }],
    },
  ],
});

🏗️ Core concepts

Agents

Agents are the central building blocks in Agenite. An agent:

• Orchestrates interactions between LLMs and tools
• Manages conversation state and context
• Handles tool execution and results
• Supports nested execution for complex workflows
• Provides streaming capabilities for real-time interactions

Tools

Tools extend agent capabilities by providing specific functionalities:

• Strong type safety with TypeScript
• JSON Schema validation for inputs
• Flexible error handling
• Easy API integration

Providers

Currently supported LLM providers:

• OpenAI API (GPT models)
• Anthropic API (Claude models)
• AWS Bedrock (Claude, Titan models)
• Local models via Ollama

Model Context Protocol (MCP)

MCP is a standardized protocol for connecting LLMs to data sources:

• Client implementation for interacting with MCP servers
• Access to web content, filesystem, databases, and more
• Similar to how USB-C provides universal hardware connections

🔄 Advanced features

Multi-agent systems

// Create specialist agents
const calculatorAgent = new Agent({
  name: 'calculator-specialist',
  provider,
  tools: [calculatorTool],
  description: 'Specializes in mathematical calculations',
});

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

// Create a coordinator agent
const coordinatorAgent = new Agent({
  name: 'coordinator',
  provider,
  agents: [calculatorAgent, weatherAgent],
  instructions: 'Coordinate between specialist agents to solve complex problems.',
});

Step-based execution

// Create an iterator for fine-grained control
const iterator = agent.iterate({
  messages: [{ role: 'user', content: [{ type: 'text', text: 'Calculate 25 divided by 5, then multiply by 3' }] }],
  stream: true,
});

// Process the stream with custom handling
for await (const chunk of iterator) {
  switch (chunk.type) {
    case 'agenite.llm-call.streaming':
      console.log(chunk.content);
      break;
    case 'agenite.tool-call.params':
      console.log('Using tool:', chunk.toolUseBlocks);
      break;
    case 'agenite.tool-result':
      console.log('Tool result:', chunk.result);
      break;
  }
}

📚 Documentation

For comprehensive documentation, visit docs.agenite.com:

• Introduction
• Quick start guide
• Core concepts
• Examples
• API reference

🤝 Community

• GitHub Discussions
• Discord Community

🛠️ Development

git clone https://github.com/subeshb1/agenite.git
cd agenite
pnpm install
pnpm build

📄 License

MIT

🌟 Star history