Voltagent
AI Agent Engineering Platform built on an Open Source TypeScript AI Agent Framework
Install / Use
/learn @VoltAgent/VoltagentREADME
VoltAgent is an end-to-end AI Agent Engineering Platform that consists of two main parts:
- Open-Source TypeScript Framework – Memory, RAG, Guardrails, Tools, MCP, Voice, Workflow, and more.
- VoltOps Console
CloudSelf-Hosted– Observability, Automation, Deployment, Evals, Guardrails, Prompts, and more.
Build agents with full code control and ship them with production-ready visibility and operations.
<h2 id="core-framework">Core TypeScript Framework</h2>With the open-source framework, you can build intelligent agents with memory, tools, and multi-step workflows while connecting to any AI provider. Create sophisticated multi-agent systems where specialized agents work together under supervisor coordination.
- Core Runtime (
@voltagent/core): Define agents with typed roles, tools, memory, and model providers in one place so everything stays organized. - Workflow Engine: Describe multi-step automations declaratively rather than stitching together custom control flow.
- Supervisors & Sub-Agents: Run teams of specialized agents under a supervisor runtime that routes tasks and keeps them in sync.
- Tool Registry & MCP: Ship Zod-typed tools with lifecycle hooks and cancellation, and connect to Model Context Protocol servers without extra glue code.
- LLM Compatibility: Swap between OpenAI, Anthropic, Google, or other providers by changing config, not rewriting agent logic.
- Memory: Attach durable memory adapters so agents remember important context across runs.
- Resumable Streaming: Let clients reconnect to in-flight streams after refresh and continue receiving the same response.
- Retrieval & RAG: Plug in retriever agents to pull facts from your data sources and ground responses (RAG) before the model answers.
- VoltAgent Knowledge Base: Use the managed RAG service for document ingestion, chunking, embeddings, and search.
- Voice: Add text-to-speech and speech-to-text capabilities with OpenAI, ElevenLabs, or custom voice providers.
- Guardrails: Intercept and validate agent input or output at runtime to enforce content policies and safety rules.
- Evals: Run agent eval suites alongside your workflows to measure and improve agent behavior.
MCP Server (@voltagent/mcp-docs-server)
You can use the MCP server @voltagent/mcp-docs-server to teach your LLM how to use VoltAgent for AI-powered coding assistants like Claude, Cursor, or Windsurf. This allows AI assistants to access VoltAgent documentation, examples, and changelogs directly while you code.
📖 How to setup MCP docs server
⚡ Quick Start
Create a new VoltAgent project in seconds using the create-voltagent-app CLI tool:
npm create voltagent-app@latest
This command guides you through setup.
You'll see the starter code in src/index.ts, which now registers both an agent and a comprehensive workflow example found in src/workflows/index.ts.
import { VoltAgent, Agent, Memory } from "@voltagent/core";
import { LibSQLMemoryAdapter } from "@voltagent/libsql";
import { createPinoLogger } from "@voltagent/logger";
import { honoServer } from "@voltagent/server-hono";
import { openai } from "@ai-sdk/openai";
import { expenseApprovalWorkflow } from "./workflows";
import { weatherTool } from "./tools";
// Create a logger instance
const logger = createPinoLogger({
name: "my-agent-app",
level: "info",
});
// Optional persistent memory (remove to use default in-memory)
const memory = new Memory({
storage: new LibSQLMemoryAdapter({ url: "file:./.voltagent/memory.db" }),
});
// A simple, general-purpose agent for the project.
const agent = new Agent({
name: "my-agent",
instructions: "A helpful assistant that can check weather and help with various tasks",
model: openai("gpt-4o-mini"),
tools: [weatherTool],
memory,
});
// Initialize VoltAgent with your agent(s) and workflow(s)
new VoltAgent({
agents: {
agent,
},
workflows: {
expenseApprovalWorkflow,
},
server: honoServer(),
logger,
});
Afterwards, navigate to your project and run:
npm run dev
When you run the dev command, tsx will compile and run your code. You should see the VoltAgent server startup message in your terminal:
══════════════════════════════════════════════════
VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
✓ HTTP Server: http://localhost:3141
Test your agents with VoltOps Console: https://console.voltagent.dev
══════════════════════════════════════════════════
Your agent is now running! To interact with it:
- Open the Console: Click the VoltOps LLM Observability Platform link in your terminal output (or copy-paste it into your browser).
- Find Your Agent: On the VoltOps LLM Observability Platform page, you should see your agent listed (e.g., "my-agent").
- Open Agent Details: Click on your agent's name.
- Start Chatting: On the agent detail page, click the chat icon in the bottom right corner to open the chat window.
- Send a Message: Type a message like "Hello" and press Enter.
Running Your First Workflow
Your new project also includes a powerful workflow engine.
The expense approval workflow demonstrates human-in-the-loop automation with suspend/resume capabilities:
import { createWorkflowChain } from "@voltagent/core";
import { z } from "zod";
export const expenseApprovalWorkflow = createWorkflowChain({
id: "expense-approval",
name: "Expense Approval Workflow",
purpose: "Process expense reports with manager approval for high amounts",
input: z.object({
employeeId: z.string(),
amount: z.number(),
category: z.string(),
description: z.string(),
}),
result: z.object({
status: z.enum(["approved", "rejected"]),
approvedBy: z.string(),
finalAmount: z.number(),
}),
})
// Step 1: Validate expense and check if approval needed
.andThen({
id: "check-approval-needed",
resumeSchema: z.object({
approved: z.boolean(),
managerId: z.string(),
comments: z.string().optional(),
adjustedAmount: z.number().optional(),
}),
execute: async ({ data, suspend, resumeData }) => {
// If we're resuming with manager's decision
if (resumeData) {
return {
...data,
approved: resumeData.approved,
approvedBy: resumeData.managerId,
finalAmount: resumeData.adjustedAmount || data.amount,
};
}
// Check if manager approval is needed (expenses over $500)
if (data.amount > 500) {
await suspend("Manager approval required", {
employeeId: data.employeeId,
requestedAmount: data.amount,
});
}
// Auto-approve small expenses
return {
...data,
approved: true,
approvedBy: "system",
finalAmount: data.amount,
};
},
})
// Step 2: Process the final decision
.andThen({
id: "process-decision",
execute: async ({ data }) => {
return {
status: data.approved ? "approved" : "rejected",
approvedBy: data.approvedBy,
finalAmount: data.finalAmount,
};
},
});
You can test the pre-built expenseApprovalWorkflow direc
