text stringlengths 0 59.1k |
|---|
## Why VoltAgent? |
As outlined in our [Manifesto](/about), 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: |
```bash |
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](/docs/)** 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](https://github.com/VoltAgent/voltagent/issues) |
- **Ask Questions & Share Ideas:** [Discord](http://s.voltagent.dev/discord) |
- **Contribute:** [Contribution Guide](/docs/community/contributing) |
We're incredibly excited to see what you build with VoltAgent. Let's redefine AI development for JavaScript together! |
--- |
The VoltAgent Team |
<|endoftext|> |
# source: VoltAgent__voltagent/website/blog/2025-05-23-llm-agent-framework/index.md type: docs |
--- |
title: What an LLM Agent Framework Looks Like in 2025 |
description: Why is building real AI applications from LLMs so hard? Discover how agent frameworks solve this problem and explore the future of modern AI development. |
tags: [llm, frameworks] |
slug: llm-agent-framework |
image: https://cdn.voltagent.dev/2025-05-23-llm-agent-framework/social.png |
authors: omeraplak |
--- |
import AgentFeaturePrioritizer from '@site/src/components/blog-widgets/AgentFeaturePrioritizer'; |
import CostOptimizationCalculator from '@site/src/components/blog-widgets/CostOptimizationCalculator'; |
import ZoomableMermaid from '@site/src/components/blog-widgets/ZoomableMermaid'; |
_"ChatGPT is amazing, but how do I integrate this into my own app?"_ - How many developers have heard this question... |
LLMs changed our lives, no doubt about it. Since ChatGPT came out, everyone sees _incredible_ possibilities. But let me tell you the truth as a developer: Using this power in our own applications is way harder than we thought. |
Most of us go through the same cycle. First there's **excitement**: "I have an amazing AI idea!" Then **quick start**: We do API integration, simple examples work, everything looks good. But when real users come... _that's when everything gets complicated._ Code becomes unmanageable, every new feature breaks old code, ... |
Did you go through this cycle? You're not alone. |
## The Real Problem: From API to Application |
When you look at AI development with the traditional approach, it looks like this: |
```javascript |
// Manual API call every time |
const response = await openai.chat.completions.create({ |
messages: [{ role: "user", content: userInput }], |
}); |
// Custom code for every feature... |
``` |
No problem at first. But then user requests start coming: "Can it use this tool?", "Can it remember past conversations?", "Can it behave differently in different situations?" You write code from scratch for every request. You solve the same problems over and over. |
This is where an LLM agent framework comes in right here. They hide complexity behind abstraction layers: |
```javascript |
// Define agent once, complexity handled by framework |
const agent = new Agent({ |
name: "customer-support", |
instructions: "Do customer support", |
tools: [orderTool, refundTool], |
memory: conversationMemory, |
}); |
``` |
See the difference? The framework handles those thousands of lines of boilerplate code, error handling, memory management, tool orchestration and gives you a chance to _just focus on business logic_. |
## What's Out There? |
At this point, developers have three main options. |
Those who choose the **DIY approach** want full control but their lives become _hell_. They write everything from scratch, solve the same problems over and over. Might be reasonable for companies with big engineering teams but overkill for most projects. |
Those who choose **no-code/low-code platforms** start fast but then hit walls. Visual editors are nice, don't require technical knowledge at first but when you want a custom feature, you get "you can't do that" as an answer. Vendor lock-in risk is also a pain. |
**LLM agent framework** find a place between the two. They give you ready-made building blocks but don't compromise on flexibility. Production-ready, best practices built-in but you can customize however you want. |
When deciding which option to go with, think about these: How's the programming language support? Is switching between LLM providers easy? What's the performance and scalability situation? How's the documentation quality? Is there community support? Are error handling, monitoring, security features good? |
<ZoomableMermaid chart={` |
graph TD |
A[AI Development Approach] --> B[DIY Approach] |
A --> C[Agent Frameworks] |
A --> D[No-Code Platforms] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.