๐Ÿ“ฆ

agenite

by subeshb1/agenite

0 views

๐Ÿค– Build powerful AI agents with TypeScript. Agenite makes it easy to create, compose, and control AI agents with first-class support for tools, streaming, and multi-agent architectures. Switch seamlessly between providers like OpenAI, Anthropic, AWS Bedrock, and Ollama.

typescriptAPI Integration

๐Ÿค– Agenite

Agenite Logo

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

GitHub license npm version TypeScript PRs Welcome

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

PackageDescriptionInstallation
Core packages
@agenite/agentCore agent orchestration framework for managing LLM interactions, tool execution, and state managementnpm install @agenite/agent
@agenite/toolTool definition framework with type safety, schema validation, and error handlingnpm install @agenite/tool
@agenite/llmBase provider interface layer that enables abstraction across different LLM providersnpm install @agenite/llm
Provider packages
@agenite/openaiIntegration with OpenAI's API for GPT models with function calling supportnpm install @agenite/openai
@agenite/anthropicIntegration with Anthropic's API for Claude modelsnpm install @agenite/anthropic
@agenite/bedrockAWS Bedrock integration supporting Claude and other modelsnpm install @agenite/bedrock
@agenite/ollamaIntegration with Ollama for running models locallynpm install @agenite/ollama
MCP package
@agenite/mcpModel Context Protocol client for connecting to standardized data sources and toolsnpm install @agenite/mcp
Middleware packages
@agenite/pretty-loggerColorful console logging middleware for debugging agent executionnpm install @agenite/pretty-logger

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:

๐Ÿค Community

๐Ÿ› ๏ธ Development

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

๐Ÿ“„ License

MIT

๐ŸŒŸ Star history

Star History Chart

Install

No configuration available
For more configuration details, refer to the content on the left

Related

Related projects feature coming soon

Will recommend related projects based on sub-categories