In this article, I'll demonstrate how we can implemented the Model Context Protocol (MCP) by integrating VoltAgent and Peaka to create an AI agent with data retrieval capabilities.

Wait, What's Peaka?​

Right, before I show you the code stuff, let me tell you about Peaka.

Their idea is pretty simple: make it less annoying to work with data. Think of it like a data middleman. You hook up your databases, spreadsheets, whatever, to Peaka. Then you can ask it questions (using fancy SQL code or just regular English), and it pulls the info together from all those places for you.

Usually, connecting different data sources is a real pain and costs a lot. Peaka feels like a simpler option, especially if you're not a huge company or just don't want to mess with complicated data pipelines. They wanna be the easy button for getting data.

And VoltAgent?​

It's our toolkit for putting together AI powered applications. We provide the core engine (@voltagent/core) to get you started, and then you can add extra capabilities, like voice interaction (@voltagent/voice) or support for different LLMs (OpenAI, Google, etc.). VoltAgent handles the complex stuff (like history and tool connections) so you can focus on your agent's unique features.

We designed VoltAgent to hit a nice sweet spot. It gives you more helpful structure than trying to build everything from raw AI libraries, but it offers a lot more freedom and customization than the simpler no-code platforms out there.

Making My Agent Talk to Peaka​

Okay, so my plan was: build a chatbot with VoltAgent that could answer questions by checking data in Peaka.

To make these two talk, I used something called MCP (Model Context Protocol). It sounds fancy, but it's basically just a standard way for different programs to give each other tasks. If you wanna know more, I wrote about what MCP is over here.

For this project, it lets VoltAgent tell Peaka, "Hey, go run this data query!"

To follow along, you'll want to sign up for a free Peaka account first over at https://www.peaka.com/. For this example, I'm just using the sample data they provide, which you'll have access to once you sign up.

Here's how I did it.

1. Starting a New VoltAgent Project​

First up, I needed a blank VoltAgent project. Their setup tool makes this easy:

npm create voltagent-app@latest my-peaka-agent
# Answer the questions it asks
cd my-peaka-agent

That just makes a folder with the basic files I need to get started.

2. Telling VoltAgent About Peaka (The MCP Bit)​

This is where the magic happens. I had to edit the main code file (src/index.ts) to tell VoltAgent how to find and talk to the Peaka tool using MCP.

This is the key chunk of code I put in:

import { VoltAgent, Agent, MCPConfiguration } from "@voltagent/core";
import { VercelAIProvider } from "@voltagent/vercel-ai"; // Using Vercel's helper stuff for the AI
import { openai } from "@ai-sdk/openai"; // And using OpenAI's model

// 1. Set up the connection to the Peaka MCP tool
const mcp = new MCPConfiguration({
  id: "peaka-mcp", // Just a nickname for this setup
  servers: {
    // Here's the info for the Peaka tool
    peaka: {
      type: "stdio", // Means it runs like a command-line program
      command: "npx", // The command to start it
      // npx is neat, it grabs the latest Peaka MCP tool automatically
      args: ["-y", "@peaka/mcp-server-peaka@latest"],
      // Gotta give it my Peaka API key (stored safely elsewhere!)
      env: { PEAKA_API_KEY: process.env.PEAKA_API_KEY || "" },
    },
  },
});

// 2. Find out what the Peaka tool can actually *do*
// (Need this `async` stuff because it takes a moment to connect)
(async () => {
  // Ask the MCP connection: "What tools does Peaka give us?"
  const tools = await mcp.getTools();

  // 3. Create our actual chatbot agent
  const agent = new Agent({
    name: "Peaka Data Assistant",
    description: "I can look things up in Peaka's data.",
    llm: new VercelAIProvider(), // Which AI service to use
    model: openai("gpt-4o-mini"), // Which specific AI brain
    tools, // <-- Super important! Give the agent the tools from Peaka!
  });

  // 4. Fire up VoltAgent
  new VoltAgent({
    agents: {
      // Make our agent live
      agent,
    },
  });

  console.log("VoltAgent is running with Peaka powers!");
})();

So, what's happening here?

1. MCPConfiguration: I'm telling VoltAgent, "There's this Peaka tool you can run. Use npx to find the @peaka/mcp-server-peaka thing, and give it my API key when you run it." The stdio part just means it runs like a regular program on my computer.
2. mcp.getTools(): This is the clever bit. VoltAgent starts the Peaka tool and then asks it, "What can you do?" Peaka sends back a list of its abilities (like querying data).
3. new Agent(...): I'm making the chatbot itself. I give it a name, tell it what AI brain to use (gpt-4o-mini), and crucially, pass in those tools I got from Peaka. Now the chatbot knows it has these extra data powers.
4. new VoltAgent(...): This just starts the main VoltAgent system with my new agent included.

Before running, I needed my API keys. I made a file called .env in the project folder and put them in there:

PEAKA_API_KEY=your_secret_peaka_key
# Don't forget your OpenAI key!
OPENAI_API_KEY=your_secret_openai_key

(Use your real keys, obviously! Keep 'em secret!)

3. Running It and Asking Stuff​

Okay, code's ready, keys are in place. Time to run it!

npm run dev

My terminal showed VoltAgent starting up, and it also started the Peaka tool automatically in the background. I saw something like this:

══════════════════════════════════════════════════
  VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
  ✓ HTTP Server: http://localhost:3141

  Developer Console:    https://console.voltagent.dev
══════════════════════════════════════════════════

Now the fun test:

1. I popped open the VoltAgent Console in my browser.

2. Found my agent ("Peaka Data Assistant").

3. Opened the chat window.

4. Asked it something that needed data from Peaka, maybe like:

   "Hey, what was my Stripe balance yesterday?"

Here's the cool part of what goes on:

• The chatbot AI gets my question.
• It figures out I need data and sees it has that Peaka tool.
• It decides to use the tool.
• VoltAgent sends the request over to the Peaka tool (using MCP).
• The Peaka tool does its thing, querying my actual Stripe data (or whatever I connected).
• Peaka sends the answer back to VoltAgent.
• VoltAgent gives the raw answer back to the chatbot AI.
• The AI turns that raw data into a normal sentence and shows it to me in the chat.

It looks something like this:

Conclusion​

Getting Peaka hooked up to my VoltAgent bot with MCP wasn't too bad! It's pretty awesome to have a chatbot that can actually use real-time data from different places. I can see this being useful for building smarter internal tools, helpdesk bots that know current info, or anything where the AI needs to know more than just what it was trained on.

Definitely worth playing around with if you're building AI stuff!

Ever built an AI agent and wondered how it actually does stuff in the real world? Like, how does it browse the web, read a file from your computer, or talk to a database?

It turns out a key piece of the puzzle is something called the Model Context Protocol, or MCP. It sounds technical, but the core idea is pretty neat and solves a big problem.

In this post, I'll walk you through:

• What is MCP
• Why Should I Care About MCP?
• Finding MCP Servers
• Introducing VoltAgent
• VoltAgent and MCP
• Let's Build an Example with VoltAgent!
  • Setting Up the Project
  • Implementing the Agent and MCP Configuration
  • Running the Agent
  • Testing in the Console

What is MCP?​

I like to think of an AI agent as a very smart brain in a jar. It's brilliant at understanding and generating language, but it's stuck inside its digital container. It doesn't have built-in hands or eyes to interact directly with the outside world files, websites, databases, APIs, etc. To do useful tasks, it needs tools.

Instead of every tool (like a file reader or a web browser) needing a unique, custom connection to the AI agent, MCP provides a standard way for agents and tools (which we call "MCP servers") to communicate.

This means an agent I build with a framework that understands MCP can potentially connect to any service or tool that also speaks this standard MCP language. This could be a tool for:

• Accessing my computer's filesystem (reading/writing files).
• Browsing the web.
• Interacting with databases.
• Connecting to specific APIs (like GitHub, Slack, Google Maps, etc.).
• Running local scripts or applications on my machine.

The main benefit I see is standardization. It makes life much easier. Developers can create tools (MCP servers) knowing that any compatible agent can use them, and agent builders like me can easily add diverse capabilities without writing tons of custom integration code for each one.

Why Should I Care About MCP?​

Okay, standardization is cool, but what does that really mean for me when I'm trying to build a useful AI agent? Here's why I find it valuable:

1. Easier Tool Integration: This is the big one. I don't need to become an expert in every single API or system I want my agent to interact with. If someone's already built an MCP server for it (like reading files or searching the web), I can often just "plug it in" to my agent configuration. Less custom code, faster development.
2. Access to Specialized Tools: The AI community is building amazing things! Maybe someone created a powerful MCP server for complex financial data analysis, controlling smart home devices, or generating specific types of images. MCP allows me to potentially leverage that specialized work directly in my agent.
3. Reusability: An MCP server built for one purpose (e.g., interacting with GitHub) isn't tied to just one specific agent or even one agent framework. If another agent or platform supports MCP, that same server can potentially be reused there. Build once, use many times.
4. Focus on Agent Logic: Because MCP handles the how of communication, I can spend more of my time and brainpower designing the what and why of my agent its goals, its personality, its core decision-making process rather than getting bogged down in the plumbing of tool connections.

Finding MCP Servers​

So, where do I find these useful MCP servers? The ecosystem is definitely growing. While there isn't one single, official, all-encompassing directory (yet!), here are the places I usually look:

• Official Examples: The creators of MCP (Anthropic) and communities maintain lists of reference implementations and examples. These are great starting points:
  • Model Context Protocol - Example Servers
• Community Aggregators: Several websites have popped up specifically to collect and categorize MCP servers developed by the community. These can be gold mines:
  • mcp.so
  • MCP Explorer by Composio
• Tool/Platform Documentation: Sometimes, the documentation for a specific service or tool (like a database, an API platform like Stripe, or even software like Blender) might mention if an official or community-built MCP server is available.
• Package Managers: I can also search package managers like npm (for Node.js/TypeScript projects) for packages often named like @modelcontextprotocol/server-* or similar.

Introducing VoltAgent​

Before we dive into building, let me briefly mention VoltAgent. It simplifies building sophisticated AI agents, handling things like state management, tool usage, and, crucially for this post, integrating external systems like MCP servers. It lets me focus more on the agent's capabilities rather than the underlying infrastructure.

VoltAgent and MCP​

VoltAgent makes integrating MCP servers relatively straightforward. The core idea is to define the servers you want to use within an MCPConfiguration object and then pass the tools provided by that configuration to your Agent.

VoltAgent handles the process of:

1. Starting the Server: Running the command you specify for the MCP server (like npx @modelcontextprotocol/server-filesystem ...).
2. Connecting: Establishing communication with the running server.
3. Fetching Tools: Asking the server what capabilities (tools) it offers.
4. Making Tools Available: Exposing these tools (like readFile, writeFile) so your agent's LLM can understand and decide to use them.

You essentially declare what server you want and where it is, and VoltAgent takes care of wiring it up to your agent.

Let's Build an Example with VoltAgent​

Let's build something. I'll show you how I created a very basic VoltAgent project and connected it to the standard filesystem MCP server. This will allow our agent to read files from a specific directory on my computer.

Setting Up the Project​

The quickest way to get started with VoltAgent is using the create-voltagent-app command-line tool. Let's call our project mcp-filesystem-agent. I opened my terminal and ran:

npm create voltagent-app@latest mcp-filesystem-agent

This command guides you through setup. I mostly chose the defaults but made sure to select TypeScript. (For more details, check the VoltAgent Quick Start guide).

After it finished, I navigated into the new project directory:

cd mcp-filesystem-agent

This sets up a basic project structure:

mcp-filesystem-agent/
├── src/
│   └── index.ts     # Our main agent logic goes here!
├── package.json     # Project dependencies
├── tsconfig.json    # TypeScript configuration
├── .gitignore       # Files for Git to ignore
└── .env             # For API keys (you'll need to add your key here)

Implementing the Agent and MCP Configuration​

Now for the core part. I opened src/index.ts and set up the MCP configuration and the agent definition.

import { openai } from "@ai-sdk/openai";
import { VoltAgent, Agent, MCPConfiguration } from "@voltagent/core";
import { VercelAIProvider } from "@voltagent/vercel-ai";
// Node.js 'path' module helps create safe, cross-platform file paths
import path from "node:path";

const mcpConfig = new MCPConfiguration({
  servers: {
    filesystem: {
      // 'stdio' means VoltAgent will run this as a local command-line process
      // and communicate with it via standard input/output.
      type: "stdio",
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-filesystem", path.resolve("./data")],
    },
  },
});

const agent = new Agent({
  name: "MCP Filesystem Agent",
  description:
    "I am an agent that can read and write files inside a specific 'data' directory, using tools provided by an MCP server.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  tools: await mcpConfig.getTools(),
});

new VoltAgent({
  agents: {
    fsAgent: agent,
  },
});

Code Breakdown (My Understanding):

• MCPConfiguration: This is where I defined the filesystem server connection.
  • type: "stdio" tells VoltAgent it's a local command to run.
  • command: "npx" specifies how to run it.
  • args: [...] provides the details: the MCP server package (@modelcontextprotocol/server-filesystem) and, crucially, path.resolve("./data"). This locks the server down, only allowing it to see inside a ./data folder within my project. I had to remember to actually create this data folder later (mkdir data)! This is super important for security.
• Agent Definition: I created my Agent instance. The key part is tools: await mcpConfig.getTools(). This line tells VoltAgent: "Go connect to all the servers I defined in mcpConfig, find out what tools they offer (like readFile, writeFile from the filesystem server), and make those tools available for this agent's LLM to use."
• VoltAgent Initialization: I started the main VoltAgent server and registered my agent under the key fsAgent. This key is how I'll select it in the VoltAgent Console.

Running the Agent​

Before running, we need two things: an API key for the LLM and the data directory we restricted the MCP server to.

1. Create .env file: In the root of the mcp-filesystem-agent project, I created a file named .env.

2. Add API Key: Inside .env, I added my OpenAI key:

   .env

   OPENAI_API_KEY=your_openai_api_key_here
   

   (Obviously, replace your_openai_api_key_here with your actual key).

3. Create data Directory and Test File: In the terminal, still in the project root:

   mkdir data
   echo "Hello from the MCP agent's accessible file!" > data/test.txt
   

4. Install Dependencies: Make sure all packages are installed:

   • npm
   • yarn
   • pnpm

   npm install
   

5. Start the Agent: Run the development server:

   • npm
   • yarn
   • pnpm

   npm run dev
   

I saw the VoltAgent server startup message, including the link to the Developer Console:

══════════════════════════════════════════════════
  VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
  ✓ HTTP Server: http://localhost:3141

  Developer Console:    https://console.voltagent.dev
══════════════════════════════════════════════════

This also automatically started the filesystem MCP server process in the background.

Testing in the Console​

Now for the moment of truth!

1. Open Console: I went to https://console.voltagent.dev in my browser.
2. Find Agent: My agent was listed with the key fsAgent (and the name "MCP Filesystem Agent"). I clicked on it.
3. Chat: I clicked the chat icon (bottom-right) to open the chat window.
4. Ask it to Read: I typed the following message and hit Enter: Please read the file named test.txt in the data directory.

Here's what happened behind the scenes (which I could see in the console's trace):

1. My agent received the message.
2. The LLM understood I wanted to read a file and saw it had a readFile tool available (thanks to MCP and VoltAgent).
3. The agent decided to use the readFile tool, passing test.txt as the argument.
4. VoltAgent routed this tool call to the running filesystem MCP server process.
5. The MCP server (safely restricted to the ./data directory) read test.txt and sent its content back.
6. VoltAgent passed the content back to the agent's LLM.
7. The LLM formulated a response like, "Okay, I read the file test.txt. The content is: Hello from the MCP agent's accessible file!" and sent it to me in the chat.

The agent used an external tool via MCP to interact with my local filesystem, exactly as planned.

Conclusion​

MCP felt a bit abstract at first, but seeing it work makes its value clear. It really does act like that universal adapter, allowing my AI agent to gain new capabilities (like accessing files) just by configuring the right MCP server. VoltAgent made the process of connecting that server to the agent pretty painless.

By providing this standard communication layer, MCP opens the door for agents to safely and reliably interact with a huge range of external systems.

Chatbots have become incredibly useful, haven't they? From customer support to personal assistants, they handle conversations pretty well. But sometimes, standard chatbots hit a wall – their knowledge is limited to what they were trained on.

What if you want your chatbot to answer questions based on specific documents, recent data, or a private knowledge base?

That's where Retrieval-Augmented Generation (RAG) comes in.

Steps we'll cover:

• What RAG (Retrieval-Augmented Generation) is and why it's useful.
• How VoltAgent's Retriever system facilitates RAG.
• Setting up a VoltAgent project.
• Implementing a custom BaseRetriever with a simple knowledge base.
• Creating a VoltAgent Agent that uses the retriever directly.
• Running and testing the RAG chatbot using the VoltAgent Console.

What is RAG, and Why Use It?​

At its core, RAG is a technique that helps Large Language Models (LLMs) like the ones powering chatbots become smarter by giving them access to external information before they generate a response.

The result? Chatbots that can provide more accurate, up-to-date, and contextually relevant answers, going beyond their built-in knowledge. I find this incredibly powerful for building bots that need to know about specific product documentation, internal company policies, or recent news.

Introducing VoltAgent​

Before we dive into building, let me briefly mention VoltAgent. It's a TypeScript framework I've been working with that makes building sophisticated AI agents (like our RAG chatbot) much simpler. It handles a lot of the boilerplate, letting me focus on the core logic of my agents, including how they retrieve and use information.

VoltAgent's Retriever System​

VoltAgent provides a streamlined way to implement RAG through its Retriever system. The key component is the BaseRetriever abstract class (you can find it in @voltagent/core).

To add RAG capabilities to your agent, you essentially need to:

1. Create a Custom Retriever: Extend BaseRetriever and implement the retrieve method. This method contains your logic for fetching relevant data from your chosen source based on the user's input.
2. Connect it to an Agent: VoltAgent offers two main ways to do this, as detailed in the Retriever documentation:
   • Direct Attachment (agent.retriever): The retriever runs automatically before every LLM call for that agent. Simple, ensures context is always fetched.
   • As a Tool (agent.tools): The LLM decides when to call the retriever tool based on the conversation. More efficient and flexible, especially if retrieval isn't always needed.

For this tutorial, we'll use the direct attachment method for simplicity. Our agent will always try to fetch context from its small knowledge base before answering.

Let's Build a Simple RAG Chatbot​

Okay, theory's great, but let's get hands-on. I'll show you how I built a basic RAG chatbot using VoltAgent that answers questions based on a small, hardcoded set of facts about VoltAgent itself.

Setting Up the Project​

The easiest way to start a new VoltAgent project is using the create-voltagent-app CLI tool. For this example, let's name our project with-rag-chatbot. Open your terminal and run:

npm create voltagent-app@latest with-rag-chatbot

This command will guide you through the setup process. (For more details on using the CLI or setting up manually, check the Quick Start guide).

After the setup, navigate into your new project directory:

cd with-rag-chatbot

The CLI sets up a standard project structure for you:

with-rag-chatbot/
├── src/
│   └── index.ts     # Our main agent logic will go here
├── package.json     # Project dependencies
├── tsconfig.json    # TypeScript config
├── .gitignore       # Git ignore rules
└── .env             # API keys (important!) - created automatically or you add it

The generated package.json will be similar to these (though versions might differ slightly):

// ... (scripts, name: "with-rag-chatbot", etc.)
  "dependencies": {
    "@ai-sdk/openai": "...", // Or your chosen LLM SDK
    "@voltagent/core": "...",
    "@voltagent/vercel-ai": "...", // Or your chosen provider
    "zod": "..."
  },
// ... (devDependencies)

Now, let's focus on the code inside src/index.ts.

Implementing the Retriever and Agent​

This is where the magic happens. In src/index.ts, I defined a simple retriever and an agent that uses it.

import { VoltAgent, Agent, BaseRetriever, type BaseMessage } from "@voltagent/core";
import { VercelAIProvider } from "@voltagent/vercel-ai";
import { openai } from "@ai-sdk/openai";

// --- Simple Knowledge Base Retriever ---

class KnowledgeBaseRetriever extends BaseRetriever {
  // Our tiny "knowledge base"
  private documents = [
    {
      id: "doc1",
      content: "What is VoltAgent? VoltAgent is a TypeScript framework for building AI agents.",
    },
    {
      id: "doc2",
      content:
        "What features does VoltAgent support? VoltAgent supports tools, memory, sub-agents, and retrievers for RAG.",
    },
    { id: "doc3", content: "What is RAG? RAG stands for Retrieval-Augmented Generation." },
    {
      id: "doc4",
      content:
        "How can I test my agent? You can test VoltAgent agents using the VoltAgent Console.",
    },
  ];

  // Reverting to simple retrieve logic
  async retrieve(input: string | BaseMessage[]): Promise<string> {
    const query = typeof input === "string" ? input : (input[input.length - 1].content as string);
    const queryLower = query.toLowerCase();
    console.log(`[KnowledgeBaseRetriever] Searching for context related to: "${query}"`);

    // Simple includes check
    const relevantDocs = this.documents.filter((doc) =>
      doc.content.toLowerCase().includes(queryLower)
    );

    if (relevantDocs.length > 0) {
      const contextString = relevantDocs.map((doc) => `- ${doc.content}`).join("\n");
      console.log(`[KnowledgeBaseRetriever] Found context:\n${contextString}`);
      return `Relevant Information Found:\n${contextString}`;
    }

    console.log("[KnowledgeBaseRetriever] No relevant context found.");
    return "No relevant information found in the knowledge base.";
  }
}

// --- Agent Definition ---

// Instantiate the retriever
const knowledgeRetriever = new KnowledgeBaseRetriever();

// Define the agent that uses the retriever directly
const ragAgent = new Agent({
  name: "RAG Chatbot",
  description: "A chatbot that answers questions based on its internal knowledge base.",
  llm: new VercelAIProvider(), // Using Vercel AI SDK Provider
  model: openai("gpt-4o-mini"), // Using OpenAI model via Vercel
  // Attach the retriever directly
  retriever: knowledgeRetriever,
});

// --- VoltAgent Initialization ---

new VoltAgent({
  agents: {
    // Make the agent available under the key 'ragAgent'
    ragAgent,
  },
});

Code Breakdown:

• KnowledgeBaseRetriever: Extends BaseRetriever. It holds a small array of documents. The retrieve method performs a simple case-insensitive search. If it finds matches, it formats them into a string prefixed with "Relevant Information Found:"; otherwise, it returns a "not found" message.
• ragAgent: An Agent instance.
  • We give it a name and description.
  • We configure the llm provider and model.
  • Crucially, we set retriever: knowledgeRetriever. This tells VoltAgent to automatically run our retriever before calling the LLM.
  • The systemPrompt is important here. It explicitly tells the LLM to base its answers only on the "Relevant Information Found" (which our retriever provides) and what to do if no information is found. This helps prevent the LLM from falling back on its general knowledge.
• new VoltAgent(...): Initializes the VoltAgent server and registers our ragAgent.

Running the Agent​

Before running, you need an API key for your chosen LLM provider (like OpenAI).

1. Create .env file: In the root of your with-rag-chatbot project folder, create a file named .env.

2. Add API Key: Add your key like this: bash title=".env" OPENAI_API_KEY=your_openai_api_key_here (Replace your_openai_api_key_here with your actual key).

3. Install Dependencies: Open your terminal inside the with-rag-chatbot directory and run:

   • npm
   • yarn
   • pnpm

   npm install
   

4. Start the Agent: Run the development server:

   • npm
   • yarn
   • pnpm

   npm run dev
   

You should see the VoltAgent server startup message, including a link to the Developer Console:

══════════════════════════════════════════════════
  VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
  ✓ HTTP Server: http://localhost:3141

  Developer Console:    https://console.voltagent.dev
══════════════════════════════════════════════════

Testing in the Console​

Now for the fun part!

1. Open Console: Go to https://console.voltagent.dev in your browser.
2. Find Agent: You should see your "RAG Chatbot" listed. Click on it.
3. Chat: Click the chat icon (usually bottom-right) to open the chat window.
4. Ask Questions: Try asking questions related to the documents in our retriever:
   • What is VoltAgent? (Should use doc1)
   • What features does VoltAgent support? (Should use doc2)
   • How can I test my agent? (Should use doc4)
   • What is the capital of France? (Should state it can't answer based on its knowledge base, because of our system prompt and lack of relevant documents).

Observe the responses. They should be directly based on the content from the documents array we provided! You can also check your terminal where you ran npm run dev - you'll see the logs from the KnowledgeBaseRetriever showing what context (if any) was found for each query.

Conclusion​

As you can see, implementing a basic RAG system with VoltAgent is quite straightforward. By creating a custom BaseRetriever and attaching it to an Agent, I could quickly build a chatbot grounded in specific external knowledge.

This simple example uses hardcoded data, but you could easily adapt the KnowledgeBaseRetriever to fetch data from a real database, API, or vector store for much more powerful applications. RAG opens up a lot of possibilities for creating smarter, more knowledgeable AI agents, and I think VoltAgent makes it significantly easier to get started.

Steps we'll cover:

• What Are Multi-Agent LLM Systems?
• Why I Started Using Multi-Agent Systems and Their Benefits
  • Are There Any Downsides? My Experience with Challenges
• Choosing the Right LLM for Your Agents
• How I Use VoltAgent for Multi-Agent Systems
  • Let Me Show You a Practical Example with VoltAgent
• My Final Thoughts

What Are Multi-Agent LLM Systems?​

Simply put, I see an agent system like having multiple specialist AI agents working together to accomplish an objective. I think of it like project work where individuals have specific talents. In my experience, there is often one "boss" agent that oversees the team to assign individual tasks to individual "sub-agents."

The Supervisor Agent organizes all this by assigning tasks to the respective agents and collating their results before presenting the final output.

Why I Started Using Multi-Agent Systems and Their Benefits​

Instead of relying on a single AI to carry out all tasks, I've found allocating tasks between specialist agents has numerous benefits:

• Expertise: Each agent has an area of specialty (e.g., coding, translation or data analysis), leading to higher-quality results in my projects.
• Multistep workflows: Steps in tasks that have more than one step (e.g., product concept creation, market research, preparation of presentations) become more manageable. The flow is coordinated by the supervisor.
• Scalability & Modularity: Sub-problems of complex tasks are broken down. I find integrating new, specialist agents is easy, or existing ones can simply be modified.
• Enhanced Quality Output: Through concentrated capabilities of task-specific agents for individual sections of an inquiry, overall performance in terms of output is improved.
• Flexibility: Any combination of agents can perform more than one task, giving me more options.

Are There Any Downsides? My Experience with Challenges​

Like any technology I work with, multi-agent systems aren't without their challenges:

• Coordination Complexity: Coordination between agents involves delegating tasks, including communication, that adds complexity to my setups.
• Dealing with errors: A single agent's mistake or miscommunication can influence all processes, making it hard sometimes to pinpoint where the issue lies.
• Cost: Deploying multiple agents can potentially be computationally more expensive than deploying one. Fortunately, modern architectures like VoltAgent, which I'll discuss next, help address these limitations.

Choosing the Right LLM for Your Agents​

Selecting the appropriate Large Language Model (LLM) for each agent, including the supervisor, is a key part of designing an effective multi-agent system. It's not always necessary, or even optimal, for every agent to use the same model. Here are a few things I consider:

• Task Needs: Does an agent need strong reasoning (like a supervisor might), creative flair (like a writer), or specific knowledge (like a coder)? I try to match the model's strengths to the agent's role.
• Cost & Speed: More powerful models often deliver better results but come at a higher cost and potentially slower response times. I might use a top-tier model for the supervisor or critical tasks, but opt for faster, cheaper models (like gpt-4o-mini in my example) for simpler, high-frequency subtasks.
• Mixing Models: One of the advantages I find with VoltAgent is the flexibility to easily assign different LLMs to different agents. This allows me to optimize both performance and cost across the entire system.

Instead of just reading my considerations, try this interactive guide to get a suggestion based on your needs:

Remember, these are just starting points. Ultimately, I recommend experimenting...

How I Use VoltAgent for Multi-Agent Systems​

I've found VoltAgent to be an effective tool for creating AI agents, and I can develop multiple agents simply using its Supervisor Agents and Subagents.

1. Define Agents: First, I define my subagents that specialize in a particular task (e.g., "Story Writer" agent, "Translator" agent). An agent consists of a name, description (instructions), and the LLM it uses.
2. Build the Supervisor: Second, I build the supervisor agent that will manage these subagents. In defining the supervisor, I simply specify which subagents it will manage using the subAgents parameter.
3. Automatic Installation: What I like is that whenever I install a supervisor agent, VoltAgent automatically configures the following in the background:

• It revises the supervisor's system message (i.e., its basic instructions) to include instructions on treating its subagents.
• Includes in the supervisor an additional delegate_task tool that allows it to delegate tasks to subagents.
• Holds records for agent relations.

4. Task Flow: The process usually goes like this:

• I forward my request to the supervisor agent.
• The supervisor reviews the request to select which subagents will most effectively accomplish the task.
• It uses delegate_task to delegate the task(s) to the corresponding subagents.
• Subagents carry out their assignments and report their results back to the supervisor.
• The supervisor combines results from all subagents and provides the final answer.

Let Me Show You a Practical Example with VoltAgent​

Let me walk you through the story writing and translation example I built. First, I needed a VoltAgent project, which I created easily using the command line:

npm create voltagent-app@latest my-multi-agent-project
cd my-multi-agent-project

Before proceeding, I needed to provide my OpenAI API key. I created a file named .env in the root of my my-multi-agent-project directory and added my key like this:

# .env file
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Replace sk-proj-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx with your actual OpenAI API key. VoltAgent automatically loaded this key for me.

This command set up my basic VoltAgent project structure 🎉

Now, I modified the agent logic (typically in a file like src/index.ts or similar within the new project) to implement my supervisor and subagents:

// Inside your VoltAgent project (e.g., src/index.ts)
import { VoltAgent, Agent } from "@voltagent/core";
import { VercelAIProvider } from "@voltagent/vercel-ai";
import { openai } from "@ai-sdk/openai";

// 1. Create Subagents
const storyWriter = new Agent({
  name: "Story Writer",
  description: "You are an expert at writing creative and engaging short stories.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
});

const translator = new Agent({
  name: "Translator",
  description: "You are a skilled translator, proficient in translating text accurately.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
});

// 2. Create the Supervisor Agent (linking subagents)
const supervisorAgent = new Agent({
  name: "Supervisor Agent",
  description:
    "You manage workflows between specialized agents. " +
    "When asked for a story, use the Story Writer. " +
    "Then, use the Translator to translate the story. Present both versions to the user.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  // Connect the subagents here
  subAgents: [storyWriter, translator],
});

new VoltAgent({
  agents: {
    supervisorAgent,
  },
});

After saving this code (e.g., in src/index.ts), I opened my terminal in the project directory (my-multi-agent-project) and installed the necessary dependencies:

npm install

Once the dependencies were installed, I started the VoltAgent development server:

npm run dev

I saw output similar to this in my terminal, indicating the server was running:

══════════════════════════════════════════════════
  VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
  ✓ HTTP Server: http://localhost:3141

  Developer Console:    https://console.voltagent.dev
══════════════════════════════════════════════════

Then, I opened my web browser and navigated to the Developer Console URL shown (https://console.voltagent.dev).

Inside the console:

1. I could see my agents listed. I clicked on "Supervisor Agent".
2. In the agent details view, I clicked the chat icon (usually in the bottom right).
3. I typed my request into the chat input: Write a short story about a robot learning to paint and translate it to German. and pressed Enter.

The Supervisor Agent then executed the workflow: it first delegated the story writing task to the Story Writer subagent, then delegated the translation task to the Translator subagent, and finally presented both results in the chat interface. I found that VoltAgent handled all the background coordination automatically.

My Final Thoughts​

In my view, Multi-agent LLM systems represent the next step in AI capabilities. I've seen how they break hard challenges down, combine multiple areas of knowledge, and permit more powerful, more flexible solutions. For me, VoltAgent has been an invaluable instrument that simplifies designing and embedding these sophisticated systems.

Are you ready to build your own AI team? I hope this guide helps!

Welcome to your first VoltAgent project! In this tutorial, we'll guide you through building a practical AI agent system that analyzes GitHub repositories. We'll fetch star counts and contributor lists, then use another agent to analyze this information. This example demonstrates the power of VoltAgent's multi-agent architecture.

Prerequisites​

Before we start, make sure you have:

• Node.js installed (LTS version recommended).
• An OpenAI API key (or an API key for another supported LLM provider).

Step 1: Create Your VoltAgent Project​

First, let's set up a new VoltAgent project. We'll use the create-voltagent-app CLI for a quick start. Open your terminal and run:

npm create voltagent-app@latest github-repo-analyzer

Follow the prompts:

1. Select your preferred package manager (npm, yarn, or pnpm).

Once the setup is complete, navigate into your new project directory:

cd github-repo-analyzer

And create a .env file in the root of the project to store your API key:

OPENAI_API_KEY=sk-proj-

Replace sk-proj- with your actual OpenAI API key.

Step 2: Understanding the Goal​

Our goal is to create an agent system that takes a GitHub repository URL (like https://github.com/voltagent/voltagent or simply voltagent/voltagent) and provides an analysis based on its star count and contributors.

To achieve this, we'll use a supervisor-worker pattern:

1. Supervisor Agent: Takes the user's input (the repo URL) and coordinates the work.
2. Stars Fetcher Agent: Fetches the star count for the repo.
3. Contributors Fetcher Agent: Fetches the list of contributors for the repo.
4. Analyzer Agent: Takes the star count and contributor list and generates insights.

Step 3: Setting Up the Tools (Conceptual)​

Agents often need tools to interact with the outside world (like APIs). In a real application, you would define tools to fetch data from the GitHub API. For this tutorial, imagine we have two pre-built tools:

• fetchRepoStarsTool: A tool that takes a repository name (e.g., voltagent/core) and returns the number of stars.
• fetchRepoContributorsTool: A tool that takes a repository name and returns a list of contributors.

(To learn how to create your own tools, check out the Tool Creation documentation.)

Let's assume these tools are defined in a separate file, perhaps src/tools.ts. We'll import them into our main agent file.

Step 4: Defining the Agents​

Now, let's define our agents in src/index.ts. Open this file and replace its contents with the following code:

import { VoltAgent, Agent } from "@voltagent/core";
import { VercelAIProvider } from "@voltagent/vercel-ai";
import { openai } from "@ai-sdk/openai";

// Assume these tools are defined elsewhere (e.g., src/tools.ts)
// import { fetchRepoContributorsTool, fetchRepoStarsTool } from "./tools";

// --- Mock Tools for Demonstration ---
// In a real scenario, you'd use actual tool implementations.
// We use simple functions here to illustrate agent structure.
const mockFetchRepoStarsTool = {
  name: "fetchRepoStars",
  description: "Fetches the star count for a given GitHub repository (owner/repo).",
  parameters: {
    type: "object",
    properties: {
      repo: { type: "string", description: 'Repository name (e.g., "voltagent/core")' },
    },
    required: ["repo"],
  },
  execute: async ({ repo }: { repo: string }) => ({ stars: Math.floor(Math.random() * 5000) }), // Mock data
};

const mockFetchRepoContributorsTool = {
  name: "fetchRepoContributors",
  description: "Fetches the contributors for a given GitHub repository (owner/repo).",
  parameters: {
    type: "object",
    properties: {
      repo: { type: "string", description: 'Repository name (e.g., "voltagent/core")' },
    },
    required: ["repo"],
  },
  execute: async ({ repo }: { repo: string }) => ({ contributors: ["UserA", "UserB", "UserC"] }), // Mock data
};
// --- End Mock Tools ---

// 1. Create the stars fetcher agent
const starsFetcherAgent = new Agent({
  name: "StarsFetcher",
  description: "Fetches the number of stars for a GitHub repository using a tool.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  tools: [mockFetchRepoStarsTool], // Use the mock tool
});

// 2. Create the contributors fetcher agent
const contributorsFetcherAgent = new Agent({
  name: "ContributorsFetcher",
  description: "Fetches the list of contributors for a GitHub repository using a tool.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  tools: [mockFetchRepoContributorsTool], // Use the mock tool
});

// 3. Create the analyzer agent (no tools needed)
const analyzerAgent = new Agent({
  name: "RepoAnalyzer",
  description: "Analyzes repository statistics (stars, contributors) and provides insights.",
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  // This agent doesn't need tools; it processes data provided by the supervisor.
});

// 4. Create the supervisor agent that coordinates all the sub-agents
const supervisorAgent = new Agent({
  name: "Supervisor",
  description: `You are a GitHub repository analyzer. When given a GitHub repository URL or owner/repo format, you will:
1. Extract the owner/repo name.
2. Use the StarsFetcher agent to get the repository's star count.
3. Use the ContributorsFetcher agent to get the repository's contributors.
4. Pass the collected data (stars, contributors) to the RepoAnalyzer agent.
5. Return the analysis provided by the RepoAnalyzer.

Example input: https://github.com/vercel/ai-sdk or vercel/ai-sdk
`,
  llm: new VercelAIProvider(),
  model: openai("gpt-4o-mini"),
  subAgents: [starsFetcherAgent, contributorsFetcherAgent, analyzerAgent], // Assign sub-agents
});

// 5. Initialize the VoltAgent with the agent hierarchy
new VoltAgent({
  agents: {
    // We only expose the supervisor externally.
    // The supervisor will internally call the other agents.
    supervisor: supervisorAgent,
  },
});

console.log("GitHub Repo Analyzer Agent system started.");

Explanation:

1. Imports: We import necessary components from VoltAgent and AI SDK libraries.
2. Mock Tools: For simplicity, we've added mock versions of the tools directly in this file. In a real app, you'd import actual tool implementations.
3. starsFetcherAgent: Defined with a name, description, LLM configuration, and the mockFetchRepoStarsTool. Its job is solely to use this tool when asked.
4. contributorsFetcherAgent: Similar to the stars fetcher, but configured with the mockFetchRepoContributorsTool.
5. analyzerAgent: This agent doesn't need tools. Its purpose is to receive data (stars and contributors) and use its LLM capabilities to generate an analysis based on its description.
6. supervisorAgent: This is the main coordinator.
   • Its description clearly outlines the steps it needs to take.
   • Crucially, it includes the other three agents in its subAgents array. This tells the supervisor it can delegate tasks to these specific agents.
7. new VoltAgent(...): This initializes the VoltAgent system. We register the supervisorAgent under the key supervisor. This means when we interact with our application, we'll be talking directly to the supervisor.

Step 5: Run Your Agent System​

Now, let's run the agent. Go back to your terminal (make sure you're in the github-repo-analyzer directory) and run the development command:

npm run dev

yarn dev

pnpm dev

You should see the VoltAgent server startup message:

══════════════════════════════════════════════════
  VOLTAGENT SERVER STARTED SUCCESSFULLY
══════════════════════════════════════════════════
  ✓ HTTP Server: http://localhost:3141

  Developer Console: https://console.voltagent.dev
══════════════════════════════════════════════════

Step 6: Interact with Your Agent​

1. Open the Console: Go to https://console.voltagent.dev.
2. Find Your Agent: Look for the agent named supervisor (or whatever name you gave it in the new VoltAgent call).
3. Open Agent Details: Click on the supervisor agent.
4. Start Chatting: Click the chat icon.
5. Send a Message: Try sending a message like: Analyze the repo voltagent/voltagent or Tell me about https://github.com/voltagent/voltagent

The supervisor agent will now follow its instructions:

• It will likely first call the StarsFetcher to get the (mock) star count.
• Then, it will call the ContributorsFetcher for the (mock) contributor list.
• Finally, it will pass this information to the RepoAnalyzer and return the analysis to you in the chat.

You can observe this multi-step process happening in the VoltAgent Developer Console!

Conclusion​

Congratulations! You've successfully built a multi-agent system using VoltAgent. You learned how to:

• Set up a VoltAgent project.
• Define multiple agents with specific roles and tools (even mock ones).
• Create a supervisor agent to orchestrate tasks among sub-agents.
• Run and interact with your agent system via the Developer Console.

This example showcases how you can break down complex tasks into smaller, manageable units, each handled by a specialized agent.

Next Steps​

• Replace the mock tools with real implementations using the GitHub API.
• Try the full example: Check out the complete GitHub Repo Analyzer example with real tool implementations. You can also create a project directly from this example:

  npm create voltagent-app@latest -- --example github-repo-analyzer
  
• Explore different LLM providers and models.
• Learn more about Agent Memory to give your agents context.
• Dive deeper into Tool Creation.

Happy building!

Building AI agents often feels like working inside a black box. Developers find themselves buried under endless console.log statements and scattered breakpoints, trying to piece together how an agent arrived at a decision. This guesswork gets exponentially harder with multi-agent systems. Adding a new agent, or even tweaking a prompt or tool in an existing one, creates a ripple effect. How do you ensure the whole system still works as intended? How do you verify the output is still correct?

This debugging cycle is slow, frustrating, and drains productivity. Developers lose focus chasing down elusive bugs instead of building innovative features. Ensuring the reliability and correctness of complex AI flows becomes a monumental, often uncertain, task.

Developer Console: Clarity, Not Chaos​

VoltAgent was designed observability-first precisely to solve this challenge. We believe developers need clear, intuitive tools to understand and manage AI complexity. The VoltAgent Developer Console transforms AI debugging from a maze into a map.

Think of it as your visual command center for AI development:

• See the Entire Flow: Inspired by the clarity of no-code tools, the Console visualizes your entire agent structure (built with the VoltAgent framework) on an infinite canvas. Watch in real-time as your agent executes, seeing exactly which functions run, which tools are called (including details like memory/chat context, RAG retrievals, and MCP server interactions), and the decision path taken.

• Step-by-Step Timeline: Go beyond a static graph. Our timeline view lets you trace every step of an agent's journey from input to output. Understand precisely what data the agent processed and why it made specific choices at each stage.

• Real-Time State Inspection: Dive into the agent's internal state, inputs, and outputs as they happen. No more guessing what variables hold or what a tool returned.

• Effortless Multi-Agent Debugging: The visualization inherently handles multi-agent complexity. See how agents interact, pass information, and contribute to the final outcome, all in one unified view.

• Replay and Analyze: Easily revisit past agent runs (sessions). Debug intermittent issues or analyze specific scenarios by replaying the exact execution flow and state changes.

• Local and Secure: The Console connects directly to your local VoltAgent process. No sensitive agent data ever leaves your machine. Debug with complete peace of mind.

Stop Debugging, Start Building​

The impact is immediate:

• Slash Debugging Time: Developers report drastically reduced debugging time – often cutting hours of guesswork down to minutes of clear analysis. Get back to building features, faster.
• Verify Changes Instantly: Easily observe the impact of prompt changes, new tools, or added agents. Visually confirm that your updates behave as expected.
• Deploy with Confidence: Understand your AI flows deeply. Ship to production knowing your agents are working correctly and reliably.

Production Observability​

The benefits don't stop at development. The same observability that speeds up debugging provides crucial insights into production systems. When issues arise post-deployment, the Console's tracing and replay capabilities allow you to pinpoint the root cause quickly, leading to more robust and trustworthy AI applications.

The Developer Console isn't just an add-on; it's fundamental to how VoltAgent empowers you to build sophisticated AI applications with clarity, confidence, and speed.

Why VoltAgent?​

As outlined in our Manifesto, VoltAgent was born from our own experiences. We wanted the flexibility of code combined with the insightful visualization often found in visual tools, but without the lock-in. We believe the JavaScript ecosystem deserves dedicated, powerful AI tooling.

VoltAgent is our answer – a tool built by JS developers, for JS developers, aiming to make AI development less daunting and more productive.

What is VoltAgent?​

Drawing inspiration from the clarity of No-Code tools but retaining the power and flexibility developers demand, VoltAgent provides:

• A Core Framework (@voltagent/core): Robust foundations for defining agent logic, managing state, and orchestrating complex workflows.
• Exceptional Observability: Forget console.log debugging. VoltAgent offers built-in tools (check our Observability docs!) to visualize agent execution, inspect state changes, and trace requests, drastically reducing debugging time from hours to minutes.
• Seamless Integration (@voltagent/vercel-ai, etc.): Easily connect with popular AI providers and platforms (explore the providers docs).
• Command-Line Interface (@voltagent/cli): Get up and running quickly with project scaffolding and management tools via create-voltagent-app.
• Extensibility: Designed with modularity in mind, allowing for custom tools, providers, and integrations (like potential voice capabilities hinted at in @voltagent/voice).
• Clear Best Practices: We provide guidance and structure (see agents and utils docs) to help you build maintainable and scalable AI applications.

Get Started in Minutes​

Ready to ditch the black box? You can start building your first agent right now:

npm create voltagent-app@latest my-first-agent
cd my-first-agent
npm run dev # or yarn dev / pnpm dev

Dive into our Getting Started Guide for a deeper look, and open the Developer Console to see your agent in action!

Join the Community​

VoltAgent is just beginning, and we're building it in the open. We believe in the power of community (check the community docs folder for ways to connect!).

• Ask Questions & Share Ideas: Discord
• Contribute: Contribution Guide
• Report Bugs & Request Features: GitHub Issues

We're incredibly excited to see what you build with VoltAgent. Let's redefine AI development for JavaScript together!

The VoltAgent Team

The Black Box is Open: Meet VoltAgent​

Building with AI often feels like working with a black box, a challenge common across many programming ecosystems. Recognizing this, and seeing the specific needs within the JavaScript/TypeScript world where tooling hasn't kept pace with Python's maturity, we built VoltAgent. JS/TS developers deserve a framework that brings structure, clarity, and a first-class developer experience to AI agent development.

We felt this pain too. As developers who previously built and scaled open-source projects like Refine, we saw the power of community and the need for better tooling. That's why we built VoltAgent.

Today, we're thrilled to announce the first release of VoltAgent!

VoltAgent is more than just another library; it's a comprehensive framework designed from the ground up to simplify the creation, debugging, and deployment of AI agents in JavaScript and TypeScript.

What is VoltAgent?​

Drawing inspiration from the clarity of No-Code tools but retaining the power and flexibility developers demand, VoltAgent provides:

• A Core Framework (@voltagent/core): Robust foundations for defining agent logic, managing state, and orchestrating complex workflows.
• Exceptional Observability: Forget console.log debugging. VoltAgent offers built-in tools (check our Observability docs!) to visualize agent execution, inspect state changes, and trace requests, drastically reducing debugging time from hours to minutes.
• Seamless Integration (@voltagent/vercel-ai, etc.): Easily connect with popular AI providers and platforms (explore the providers docs).
• Command-Line Interface (@voltagent/cli): Get up and running quickly with project scaffolding and management tools via create-voltagent-app.
• Extensibility: Designed with modularity in mind, allowing for custom tools, providers, and integrations (like potential voice capabilities hinted at in @voltagent/voice).
• Clear Best Practices: We provide guidance and structure (see agents and utils docs) to help you build maintainable and scalable AI applications.

Beyond Logs: Meet the VoltAgent Developer Console​

Debugging AI agents often involves sifting through endless console.log statements or trying to piece together scattered information across different services. This "black box" debugging is slow, frustrating, and hinders rapid iteration.

VoltAgent changes the game with its integrated Developer Console. Think of it as a visual control center specifically designed for your AI agents:

• Visualize Execution Flow: See exactly how your agent processes information, which functions are called, which tools are used, and where decisions are made – all laid out visually in a clear graph.
• Inspect State & Data in Real-Time: No more guessing. Examine the agent's internal state, inputs, outputs, and tool interactions at any point during its execution. Understand exactly what data it's working with.
• Step-Through Tracing & Timings: Dive deep into specific runs, tracing requests and responses step-by-step to pinpoint issues quickly, and analyze the performance of each step.

This visual-first approach to observability isn't just a nice-to-have; it fundamentally improves the developer experience. It makes debugging intuitive, transforms hours of guesswork into minutes of clarity, and dramatically accelerates development cycles. This is a core part of how VoltAgent empowers you to build robust AI applications with confidence.

Why VoltAgent?​

As outlined in our Manifesto, VoltAgent was born from our own experiences. We wanted the flexibility of code combined with the insightful visualization often found in visual tools, but without the lock-in. We believe the JavaScript ecosystem deserves dedicated, powerful AI tooling.

VoltAgent is our answer – a tool built by JS developers, for JS developers, aiming to make AI development less daunting and more productive.

Get Started in Minutes​

Ready to ditch the black box? You can start building your first agent right now:

npm create voltagent-app@latest my-first-agent
cd my-first-agent
npm run dev # or yarn dev / pnpm dev

Dive into our Getting Started Guide for a deeper look.

Join the Community​

VoltAgent is just beginning, and we're building it in the open. We believe in the power of community (check the community docs folder for ways to connect!).

• Report Bugs & Request Features: GitHub Issues
• Ask Questions & Share Ideas: Discord
• Contribute: Contribution Guide

We're incredibly excited to see what you build with VoltAgent. Let's redefine AI development for JavaScript together!

The VoltAgent Team