AutoAgents

Un framework multiagente de grado producción en Rust

English | 中文 | 日本語 | Español | Français | Deutsch | 한국어 | Português (Brasil)
_{Esta traducción es mantenida por la comunidad y puede quedar desactualizada; si hay diferencias, la versión en inglés es la referencia.}

Documentación | Ejemplos | Contribuir

¿Te gusta este proyecto? Danos una estrella en GitHub

Descripción general

AutoAgents es un framework modular multiagente para construir sistemas inteligentes en Rust. Combina un modelo de agentes con seguridad de tipos, llamadas a herramientas estructuradas, memoria configurable y backends de LLM intercambiables. La arquitectura está diseñada para rendimiento, seguridad y composabilidad en servidores y edge.

Características clave

Ejecución de agentes: ReAct y ejecutores básicos, respuestas en streaming y salidas estructuradas
Herramientas: macros derivadas para herramientas y salidas, además de un runtime WASM aislado para ejecutar herramientas
Memoria: memoria de ventana deslizante con backends extensibles
Proveedores LLM: backends en la nube y locales detrás de una interfaz unificada
Optimización de LLM: Crea pipelines de LLM con pases de optimización como caché y reintentos para una inferencia más rápida y confiable
Orquestación multiagente: comunicación pub/sub tipada y gestión de entornos
Procesamiento de voz: soporte local de TTS y STT
Observabilidad: trazas y métricas OpenTelemetry con exportadores conectables

Proveedores de LLM compatibles

Proveedores en la nube

Proveedor	Estado
OpenAI	✅
OpenRouter	✅
Anthropic	✅
DeepSeek	✅
xAI	✅
Phind	✅
Groq	✅
Google	✅
Azure OpenAI	✅
MiniMax	✅

Proveedores locales

Proveedor	Estado
Ollama	✅
Mistral-rs	✅
Llama-Cpp	✅

Proveedores experimentales

Ver https://github.com/liquidos-ai/AutoAgents-Experimental-Backends

Proveedor	Estado
Burn	⚠️ Experimental
Onnx	⚠️ Experimental

El soporte de proveedores se expande activamente según las necesidades de la comunidad.

Benchmarks

Más información en GitHub

Instalación

Requisitos previos

Rust (recomendado el último estable)
Cargo como gestor de paquetes
LeftHook para gestionar Git hooks

Prerequisite

sudo apt update
sudo apt install build-essential libasound2-dev alsa-utils pkg-config libssl-dev -y

Instalar LeftHook

macOS (Homebrew):

brew install lefthook

Linux/Windows (npm):

npm install -g lefthook

Clonar y compilar

git clone https://github.com/liquidos-ai/AutoAgents.git
cd AutoAgents
lefthook install
cargo build --workspace --all-features

Bindings de Python

AutoAgents ofrece bindings de Python como paquetes separados:

autoagents-py (API principal de Python + backends en la nube)
autoagents-guardrails-py (guardrails opcionales para LLMProvider de Python)
autoagents-llamacpp-py (backend local opcional de llama.cpp)
autoagents-mistral-rs-py (backend local opcional de mistral-rs)

Instalación de desarrollo desde este repositorio:

uv venv --python=3.12
source .venv/bin/activate          # Windows: .venv\Scripts\activate
uv pip install -U pip maturin pytest pytest-asyncio pytest-cov

# Limpia, compila e instala todos los bindings CPU en la venv activa
make python-bindings-build

# Limpia, compila e instala los bindings CPU + CUDA
make python-bindings-build-cuda

Los targets de Make eliminan artefactos obsoletos de instalaciones editables antes de recompilar, para evitar cargar archivos .abi3.so antiguos desde el árbol fuente.

Scripts de ejemplo:

Ejemplo cloud principal: bindings/python/autoagents/examples/openai_agent.py
Ejemplo llama.cpp: bindings/python/autoagents-llamacpp/examples/llamacpp_agent.py
Ejemplo mistral-rs: bindings/python/autoagents-mistralrs/examples/mistral_rs_agent.py

Ejecutar pruebas

cargo test --features "full" --workspace

Inicio rápido

use autoagents::core::agent::memory::SlidingWindowMemory;
use autoagents::core::agent::prebuilt::executor::{ReActAgent, ReActAgentOutput};
use autoagents::core::agent::task::Task;
use autoagents::core::agent::{AgentBuilder, AgentDeriveT, AgentOutputT, DirectAgent};
use autoagents::core::error::Error;
use autoagents::core::tool::{ToolCallError, ToolInputT, ToolRuntime, ToolT};
use autoagents::llm::LLMProvider;
use autoagents::llm::backends::openai::OpenAI;
use autoagents::llm::builder::LLMBuilder;
use autoagents_derive::{agent, tool, AgentHooks, AgentOutput, ToolInput};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::sync::Arc;

#[derive(Serialize, Deserialize, ToolInput, Debug)]
pub struct AdditionArgs {
    #[input(description = "Left Operand for addition")]
    left: i64,
    #[input(description = "Right Operand for addition")]
    right: i64,
}

#[tool(
    name = "Addition",
    description = "Use this tool to Add two numbers",
    input = AdditionArgs,
)]
struct Addition {}

#[async_trait]
impl ToolRuntime for Addition {
    async fn execute(&self, args: Value) -> Result<Value, ToolCallError> {
        println!("execute tool: {:?}", args);
        let typed_args: AdditionArgs = serde_json::from_value(args)?;
        let result = typed_args.left + typed_args.right;
        Ok(result.into())
    }
}

#[derive(Debug, Serialize, Deserialize, AgentOutput)]
pub struct MathAgentOutput {
    #[output(description = "The addition result")]
    value: i64,
    #[output(description = "Explanation of the logic")]
    explanation: String,
    #[output(description = "If user asks other than math questions, use this to answer them.")]
    generic: Option<String>,
}

#[agent(
    name = "math_agent",
    description = "You are a Math agent",
    tools = [Addition],
    output = MathAgentOutput,
)]
#[derive(Default, Clone, AgentHooks)]
pub struct MathAgent {}

impl From<ReActAgentOutput> for MathAgentOutput {
    fn from(output: ReActAgentOutput) -> Self {
        let resp = output.response;
        if output.done && !resp.trim().is_empty() {
            if let Ok(value) = serde_json::from_str::<MathAgentOutput>(&resp) {
                return value;
            }
        }
        MathAgentOutput {
            value: 0,
            explanation: resp,
            generic: None,
        }
    }
}

pub async fn simple_agent(llm: Arc<dyn LLMProvider>) -> Result<(), Error> {
    let sliding_window_memory = Box::new(SlidingWindowMemory::new(10));

    let agent_handle = AgentBuilder::<_, DirectAgent>::new(ReActAgent::new(MathAgent {}))
        .llm(llm)
        .memory(sliding_window_memory)
        .build()
        .await?;

    let result = agent_handle.agent.run(Task::new("What is 1 + 1?")).await?;
    println!("Result: {:?}", result);
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let api_key = std::env::var("OPENAI_API_KEY").unwrap_or("".into());

    let llm: Arc<OpenAI> = LLMBuilder::<OpenAI>::new()
        .api_key(api_key)
        .model("gpt-4o")
        .max_tokens(512)
        .temperature(0.2)
        .build()
        .expect("Failed to build LLM");

    let _ = simple_agent(llm).await?;
    Ok(())
}

AutoAgents CLI

AutoAgents CLI ayuda a ejecutar flujos de trabajo de agentes desde configuraciones YAML y a exponerlos por HTTP. Puedes verlo en https://github.com/liquidos-ai/AutoAgents-CLI.

Ejemplos

Explora los ejemplos para comenzar rápidamente:

Componentes

AutoAgents está construido con una arquitectura modular:

AutoAgents/
├── crates/
│   ├── autoagents/                # Main library entry point
│   ├── autoagents-core/           # Core agent framework
│   ├── autoagents-protocol/       # Shared protocol/event types
│   ├── autoagents-llm/            # LLM provider implementations
│   ├── autoagents-telemetry/      # OpenTelemetry integration
│   ├── autoagents-toolkit/        # Collection of ready-to-use tools
│   ├── autoagents-mistral-rs/     # LLM provider implementations using Mistral-rs
│   ├── autoagents-llamacpp/       # LLM provider implementation using LlamaCpp
│   ├── autoagents-speech/         # Speech model support for TTS and STT
│   ├── autoagents-guardrails/     # LLM Guardrails implementation
│   ├── autoagents-qdrant/         # Qdrant vector store
│   └── autoagents-derive/         # Procedural macros
├── examples/                      # Example implementations
├── bindings/                      # Bindings for different languages

Componentes principales

Agente: la unidad fundamental de inteligencia
Entorno: gestiona el ciclo de vida y la comunicación entre agentes
Memoria: sistemas de memoria configurables
Herramientas: integración de capacidades externas
Ejecutores: distintos patrones de razonamiento (ReAct, Chain-of-Thought)

Desarrollo

Ejecutar pruebas

cargo test --workspace --features default --exclude autoagents-burn --exclude autoagents-mistral-rs --exclude wasm_agent

# Coverage (requires cargo-tarpaulin)
cargo install cargo-tarpaulin
cargo tarpaulin --all-features --out html

Ejecutar benchmarks

cargo bench -p autoagents-core --bench agent_runtime

Git Hooks

Este proyecto usa LeftHook para gestionar los Git hooks. Los hooks ejecutan automáticamente:

Formato con cargo fmt --check
Linting con cargo clippy -- -D warnings
Pruebas con cargo test --all-features --workspace --exclude autoagents-burn

Contribuir

Damos la bienvenida a las contribuciones. Consulta Guía de contribución y Código de conducta.

Documentación

Documentación API: documentación completa del framework
Ejemplos: implementaciones prácticas

Comunidad

GitHub Issues: reportes de bugs y solicitudes de funciones
Discussions: preguntas y respuestas de la comunidad
Discord: únete a nuestra comunidad en https://discord.gg/zfAF9MkEtK

Rendimiento

AutoAgents está diseñado para alto rendimiento:

Eficiencia de memoria: uso de memoria optimizado con backends configurables
Concurrencia: soporte completo de async/await con tokio
Escalabilidad: escalado horizontal con coordinación multiagente
Seguridad de tipos: garantías en tiempo de compilación con el sistema de tipos de Rust

Licencia

AutoAgents tiene doble licencia:

MIT License (MIT_LICENSE)
Apache License 2.0 (APACHE_LICENSE)

Puedes elegir cualquiera según tu caso de uso.

Agradecimientos

Construido por el equipo de Liquidos AI y una gran comunidad de investigadores e ingenieros.

Agradecimientos especiales:

La comunidad Rust por su excelente ecosistema
Los proveedores de LLM por habilitar APIs de modelos de alta calidad
Todos los contribuyentes que ayudan a mejorar AutoAgents

FilesExpand file tree

README.es.md

Latest commit

History

README.es.md

File metadata and controls

AutoAgents

Descripción general

Características clave

Proveedores de LLM compatibles

Proveedores en la nube

Proveedores locales

Proveedores experimentales

Benchmarks

Instalación

Requisitos previos

Prerequisite

Instalar LeftHook

Clonar y compilar

Bindings de Python

Ejecutar pruebas

Inicio rápido

AutoAgents CLI

Ejemplos

Componentes

Componentes principales

Desarrollo

Ejecutar pruebas

Ejecutar benchmarks

Git Hooks

Contribuir

Documentación

Comunidad

Rendimiento

Licencia

Agradecimientos

Historial de estrellas