Reactive AI Agent Framework

🚀 Reactive AI Agent Framework

---

🌟 ¿Qué son los Reactive Agents?

Reactive Agents es un marco de vanguardia para agentes de IA que hace que construir agentes inteligentes y autónomos sea tan simple como Laravel hace el desarrollo web. Con su elegante patrón de construcción, ecosistema integral de herramientas y arquitectura lista para producción, puedes crear agentes de IA sofisticados que piensan, planifican, ejecutan y se adaptan.

🔎 Definición — "Reactive" (adj.)

reactive /ˈriːæk.tɪv/

1. Que responde con prontitud a cambios o estímulos externos; capaz de detectar, interpretar y actuar en tiempo real.
2. Arquitectado para ciclos de retroalimentación rápidos, adaptación consciente del contexto y toma de decisiones de baja latencia.

🚀 ¿Por qué "Reactive"?

Los agentes reactivos convierten la detección en valor instantáneo: detectan cambios, invocan las herramientas adecuadas y ajustan los planes sobre la marcha. Eso significa respuestas más rápidas, menos fallos, mejores experiencias de usuario y sistemas que escalan con gracia bajo la incertidumbre del mundo real. En resumen: reactivo = IA más rápida, más inteligente y más fiable que genera resultados confiables ahora.

🎯 Ideal para

• 🔬 Automatización de investigación - Investigación web inteligente y análisis de datos
• 📊 Inteligencia empresarial - Informes automatizados y soporte de decisiones
• 🛠️ DevOps e infraestructura - Monitoreo y automatización inteligentes
• 💬 Soporte al cliente - Asistentes inteligentes con integración de herramientas
• 📈 Procesamiento de datos - Flujos de trabajo complejos con múltiples fuentes de datos
• 🎮 Aplicaciones interactivas - Experiencias de usuario impulsadas por IA
• 🤖 Sistemas multiagente - Equipos de IA orquestados que resuelven problemas complejos
• ⚙️ Automatización y scripting - Automatización inteligente de tareas

✨ Características clave

🧠 Múltiples estrategias de razonamiento

Estrategias componibles con arquitectura basada en componentes: Las estrategias son modulares y conectables, construidas a partir de componentes discretos (planificadores, ejecutores, reflexionadores y evaluadores de objetivos) que puedes combinar para crear flujos de razonamiento personalizados.

• Componentes modulares — los planificadores, ejecutores, reflexionadores y evaluadores son independientes e intercambiables.
• Estrategias conectables — implementa BaseReasoningStrategy y regístralo con StrategyManager para añadir nuevas estrategias.
• Probables y reutilizables — componentes pequeños y bien tipados hacen que las pruebas unitarias y la reutilización sean simples.
• Diseñadas para la composición — usa la estrategia Adaptive o compón múltiples estrategias para manejar tareas complejas y dinámicas.

Las estrategias preconstruidas incluyen:

• Reactive: Resolución de problemas rápida y directa
• Plan-Execute-Reflect: Enfoque estructurado para tareas complejas
• Reflect-Decide-Act: Estrategia adaptativa para entornos dinámicos
• Adaptive: Selección de estrategia impulsada por IA según la complejidad de la tarea

🔧 Ecosistema integral de herramientas

• Herramientas Python personalizadas con el decorador @tool()
• Integración con Model Context Protocol (MCP)
• Herramientas preconstruidas: búsqueda web, operaciones de archivos, bases de datos y más
• Composición de herramientas y sistema de validación

🏗️ Arquitectura lista para producción

• Diseño basado en eventos con monitoreo en tiempo real
• Recuperación robusta de errores con mecanismos inteligentes de reintento
• Gestión de memoria con almacenamiento vectorial y persistencia
• Monitoreo de rendimiento con métricas detalladas y puntuación
• Optimización de contexto con estrategias adaptativas de poda

🔄 Gestión avanzada de flujos de trabajo

• Orquestación multiagente con gestión de dependencias
• Protocolos de comunicación A2A (agente a agente)
• Ejecución paralela y sincronización
• Plantillas de flujo de trabajo para patrones comunes

🎛️ Experiencia de desarrollador

• API de construcción fluida con valores predeterminados sensatos
• Seguridad de tipos con modelos Pydantic en todo el marco
• Registro integral con eventos estructurados
• 🚧 Sistema de complementos para extensibilidad
• Recarga en caliente para flujos de trabajo de desarrollo

---

🏁 Inicio rápido

Instalación

pip install reactive-agents

Tu primer agente (30 segundos)

import asyncio
from reactive_agents import ReactiveAgentBuilder, ReasoningStrategies

async def main():
    # Create an intelligent research agent
    agent = await (
        ReactiveAgentBuilder()
        .with_name("Research Assistant")
        .with_model("ollama:llama3")  # or "openai:gpt-4", "anthropic:claude-3-sonnet"
        .with_tools(["brave-search", "time"])  # Auto-detects MCP tools vs custom tools
        .with_instructions("Research thoroughly and provide detailed analysis")
        .with_reasoning_strategy(ReasoningStrategies.REACTIVE)
        .build()
    )

    async with agent:
        result = await agent.run(
            "What are the latest developments in quantum computing this week?"
        )
        print(result.final_answer)
        print(f"Status: {result.status_message}")

asyncio.run(main())

¡Eso es todo! Ahora tienes un agente de IA totalmente funcional que puede buscar en la web, analizar información y proporcionar respuestas completas.

🎯 Conceptos fundamentales

🤖 Arquitectura de agentes

Reactive Agents utiliza una arquitectura basada en componentes donde cada agente está compuesto por componentes especializados e intercambiables:

# The agent automatically manages these components:
ExecutionEngine  # Coordinates task execution and strategy selection
ReasoningEngine  # Handles different reasoning strategies
ToolManager     # Manages tool registration and execution
MemoryManager   # Handles persistent storage and retrieval
EventBus        # Coordinates real-time event communication
MetricsManager  # Tracks performance and provides insights

🧭 Estrategias de razonamiento

Elige la estrategia adecuada para tu tarea:

from reactive_agents import ReactiveAgentBuilder, ReasoningStrategies

# Reactive: Fast, direct execution
agent = await ReactiveAgentBuilder().with_reasoning_strategy(ReasoningStrategies.REACTIVE).build()

# Plan-Execute-Reflect: Structured approach
agent = await ReactiveAgentBuilder().with_reasoning_strategy(ReasoningStrategies.PLAN_EXECUTE_REFLECT).build()

# Adaptive: AI selects the best strategy
agent = await ReactiveAgentBuilder().with_reasoning_strategy(ReasoningStrategies.ADAPTIVE).build()  # Default

🛠️ Integración de herramientas

Múltiples formas de añadir capacidades a tus agentes:

from reactive_agents import tool

# 1. Custom Python functions with @tool decorator
@tool()
async def get_weather(city: str) -> str:
    """Get weather information for a city."""
    return f"Weather in {city}: Sunny, 72°F"

# 2. Mixed tools - auto-detection!
# Strings = MCP servers, Functions = custom tools
.with_tools([get_weather, "brave-search", "time", "filesystem"])

# 3. Or use explicit methods
.with_mcp_tools(["brave-search", "sqlite"])
.with_custom_tools([get_weather])

---

💡 Ejemplos

🔍 Agente de investigación inteligente

from reactive_agents import ReactiveAgentBuilder, tool, ReasoningStrategies

@tool()
async def analyze_trends(data: str) -> str:
    """Analyze data trends and patterns."""
    # Your analysis logic here
    return f"Trend analysis: {data}"

async def create_research_agent():
    return await (
        ReactiveAgentBuilder()
        .with_name("Research Pro")
        .with_model("openai:gpt-4")
        .with_reasoning_strategy(ReasoningStrategies.PLAN_EXECUTE_REFLECT)
        .with_tools([analyze_trends, "brave-search", "time", "filesystem"])
        .with_instructions("""
            You are a professional research analyst. Always:
            1. Search for the most recent information
            2. Cross-reference multiple sources
            3. Provide data-driven insights
            4. Save important findings to files
        """)
        .with_max_iterations(15)
        .build()
    )

📊 Agente de inteligencia empresarial

async def create_bi_agent():
    return await (
        ReactiveAgentBuilder()
        .with_name("BI Analyst")
        .with_model("anthropic:claude-3-sonnet")
        .with_tools(["sqlite", "filesystem", "brave-search"])
        .with_vector_memory("bi_agent_memory")  # Enable persistent vector memory
        .with_instructions("""
            You are a business intelligence analyst. Create comprehensive
            reports with data visualizations and actionable insights.
        """)
        .with_response_format("""
            ## Executive Summary
            [Key findings and recommendations]

            ## Data Analysis
            [Detailed analysis with charts/tables]

            ## Recommendations
            [Specific, actionable next steps]
        """)
        .build()
    )

🔄 Flujo de trabajo multiagente

from reactive_agents.workflows import WorkflowOrchestrator

async def create_content_pipeline():
    orchestrator = WorkflowOrchestrator()

    # Research agent
    researcher = await (
        ReactiveAgentBuilder()
        .with_name("Content Researcher")
        .with_tools(["brave_web_search"])
        .build()
    )

    # Writing agent
    writer = await (
        ReactiveAgentBuilder()
        .with_name("Content Writer")
        .with_tools(["filesystem"])
        .build()
    )

    # Create workflow
    workflow = (
        orchestrator
        .add_agent("research", researcher)
        .add_agent("writing", writer)
        .add_dependency("writing", "research")  # Writer waits for researcher
        .build()
    )

    return workflow

🎛️ Monitoreo basado en eventos

from reactive_agents.events import AgentStateEvent

async def create_monitored_agent():
    # Track performance in real-time
    metrics = {"tool_calls": 0, "errors": 0, "duration": 0}

    def on_tool_called(event):
        metrics["tool_calls"] += 1
        print(f"🔧 Tool used: {event['tool_name']}")

    def on_error(event):
        metrics["errors"] += 1
        print(f"❌ Error: {event['error_message']}")

    def on_completion(event):
        metrics["duration"] = event["total_duration"]
        print(f"✅ Completed in {metrics['duration']:.2f}s")
        print(f"📊 Final metrics: {metrics}")

    return await (
        ReactiveAgentBuilder()
        .with_name("Monitored Agent")
        .with_model("ollama:qwen2:7b")
        .on_tool_called(on_tool_called)
        .on_error_occurred(on_error)
        .on_session_ended(on_completion)
        .build()
    )

---

🛠️ Instalación y configuración

Requisitos previos

• Python 3.10+
• Poetry (recomendado) o pip

Instalación básica

# Using pip
pip install reactive-agents

# Using Poetry
poetry add reactive-agents

Instalación de desarrollo

# Clone the repository
git clone https://github.com/tylerjrbuell/reactive-agents
cd reactive-agents

# Install with Poetry
poetry install

# Run tests
poetry run pytest

Configuración del entorno

Crea un archivo .env:

# LLM Providers
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GROQ_API_KEY=your_groq_key
OLLAMA_HOST=http://localhost:11434

# MCP Tools
BRAVE_API_KEY=your_brave_search_key

# Optional: Custom MCP configuration
MCP_CONFIG_PATH=/path/to/custom/mcp_config.json

---

🎯 Características avanzadas

🧠 Estrategias de razonamiento personalizadas

Implementa tu propio enfoque de razonamiento:

from reactive_agents.strategies import BaseReasoningStrategy

class MyCustomStrategy(BaseReasoningStrategy):
    @property
    def name(self) -> str:
        return "my_custom_strategy"

    async def execute_iteration(self, task: str, context: ReasoningContext):
        # Your custom reasoning logic
        return StrategyResult.success(payload)

# Register and use
ReactiveAgentBuilder().with_reasoning_strategy("my_custom_strategy")

🔧 Creación de herramientas personalizadas

Construye herramientas sofisticadas con validación:

from reactive_agents.tools import tool
from pydantic import BaseModel

class WeatherRequest(BaseModel):
    city: str
    units: str = "metric"

@tool("Get detailed weather information", validation_model=WeatherRequest)
async def advanced_weather(request: WeatherRequest) -> dict:
    # Sophisticated weather logic with API calls
    weather_data = await fetch_weather_api(request.city, request.units)
    return {
        "temperature": weather_data.temp,
        "conditions": weather_data.conditions,
        "forecast": weather_data.forecast
    }

📊 Monitoreo de rendimiento

Sigue y optimiza el rendimiento de los agentes:

async def monitor_performance():
    agent = await ReactiveAgentBuilder().with_name("Performance Agent").build()

    # Get real-time metrics
    session = agent.context.session

    print(f"Completion Score: {session.completion_score}")
    print(f"Tool Usage Score: {session.tool_usage_score}")
    print(f"Overall Score: {session.overall_score}")

    # Access detailed metrics
    metrics = agent.context.metrics_manager.get_metrics()
    print(f"Total Duration: {metrics['total_time']:.2f}s")
    print(f"Tool Calls: {metrics['tool_calls']}")
    print(f"Model Calls: {metrics['model_calls']}")

🔄 Sistema de complementos 🚧

Extiende el marco con complementos:

from reactive_agents.plugins import Plugin

class CustomAnalyticsPlugin(Plugin):
    def on_load(self, framework):
        # Initialize your plugin
        self.analytics_client = AnalyticsClient()

    def on_agent_created(self, agent):
        # Hook into agent lifecycle
        agent.on_completion(self.track_completion)

    async def track_completion(self, event):
        await self.analytics_client.track(event)

# Load plugin
framework.load_plugin(CustomAnalyticsPlugin())

---

📖 Documentación

📚 Guías completas

• Guía de inicio - Tu primer agente en 5 minutos
• Descripción general de la arquitectura - Comprender el marco
• Desarrollo de herramientas - Construir herramientas e integraciones personalizadas
• Estrategias de razonamiento - Inmersión profunda en el razonamiento de IA
• Orquestación de flujos de trabajo - Coordinación multiagente
• Despliegue en producción - Escalado a producción

🔧 Referencia de API

• API del constructor de agentes - Referencia completa del patrón de construcción
• API del sistema de herramientas - Registro y ejecución de herramientas
• API del sistema de eventos - Monitoreo en tiempo real y enlaces
• API de configuración - Opciones de configuración avanzadas

💡 Ejemplos y tutoriales

• Galería de ejemplos - Más de 20 ejemplos del mundo real
• Serie de tutoriales - Ruta de aprendizaje paso a paso
• Mejores prácticas - Consejos y patrones de producción
• Solución de problemas - Problemas comunes y soluciones

---

🌐 Soporte de proveedores de modelos

Reactive Agents funciona con todos los principales proveedores de LLM:

Proveedor	Modelos	Características
OpenAI	GPT-4o, GPT-4, GPT-3.5	Llamada de funciones, transmisión, visión
Anthropic	Claude 3.5 Sonnet, Claude 3	Contexto amplio, uso de herramientas
Groq	Llama 3, Mixtral	Inferencia ultrarrápida
Ollama	Cualquier modelo local	Privacidad, personalización
Google	Gemini Pro, Gemini Flash	Capacidades multimodales

Actualización v0.1.0a7: El proveedor de Google ahora usa el SDK google-genai más reciente (v1.5.0) con rendimiento mejorado y cero advertencias de obsolescencia.

# Easy provider switching
.with_model("gpt-4o")                    # OpenAI
.with_model("claude-3-sonnet")           # Anthropic
.with_model("groq:llama3-70b")          # Groq
.with_model("ollama:qwen2:7b")          # Ollama
.with_model("google:gemini-pro")        # Google

---

🎯 Salidas estructuradas y arquitectura de proveedores

🔄 Sistema universal de salidas estructuradas

Reactive Agents implementa un sistema unificado de salidas estructuradas usando el Paquete Python Instructor en todos los proveedores de modelos. Esto garantiza una validación de modelos Pydantic consistente y seguridad de tipos independientemente del LLM que elijas.

from pydantic import BaseModel
from typing import List
from reactive_agents import ReactiveAgentBuilder

class ResearchResult(BaseModel):
    summary: str
    key_findings: List[str]
    confidence_score: float
    sources: List[str]

# Works identically across ALL providers
agent = await ReactiveAgentBuilder()\
    .with_model("ollama:qwen2:7b")  # or any provider
    .build()

# Get validated, structured output
result: ResearchResult = await agent.get_structured_response(
    ResearchResult,
    "Research the latest AI developments"
)

print(result.summary)           # ✅ Type-safe string
print(result.confidence_score)  # ✅ Type-safe float

🔧 Interfaz de parámetros estilo OpenAI

El marco usa parámetros compatibles con OpenAI como interfaz estándar, con traducción automática a formatos específicos del proveedor:

# ✅ Same parameters work everywhere
universal_options = {
    "temperature": 0.2,
    "max_tokens": 500,
    "top_p": 0.9,
    "frequency_penalty": 0.1,
    "presence_penalty": 0.05,
    "stop": ["END", "STOP"],
    "seed": 42
}

# Automatically optimized for each provider
providers = [
    "openai:gpt-4o",
    "anthropic:claude-3-5-sonnet-latest",
    "groq:llama-3.1-8b-instant",
    "ollama:cogito:14b",
    "google:gemini-2.5-flash"
]

for provider_model in providers:
    agent = await ReactiveAgentBuilder()\
        .with_model(provider_model)\
        .with_model_provider_options(universal_options)\
        .build()

    # Same code, provider-specific optimization! 🚀
    result = await agent.run("Analyze this data...")

🔄 Arquitectura de parámetros duales

El marco usa un elegante sistema de parámetros duales:

1️⃣ Capa de interfaz de usuario (estilo OpenAI)

# Clean, standardized interface
{
    "temperature": 0.3,
    "max_tokens": 200,
    "top_p": 0.8,
    "frequency_penalty": 0.1
}

2️⃣ Capa de optimización del proveedor (formatos nativos)

# Ollama native (automatically translated)
{
    "temperature": 0.3,
    "num_predict": 200,      # max_tokens → num_predict
    "top_p": 0.8,
    "repeat_penalty": 1.1,   # frequency_penalty → repeat_penalty (scaled)
    "num_ctx": 4096,         # Added Ollama optimizations
    "repeat_last_n": 64,
    "top_k": 40
}

# Anthropic native (automatically translated)
{
    "temperature": 0.3,
    "max_tokens": 200,       # Direct mapping
    "top_p": 0.8,
    "stop_sequences": ["END"] # stop → stop_sequences
}

# Groq native (automatically translated)
{
    "temperature": 0.3,
    "max_completion_tokens": 200,  # max_tokens → max_completion_tokens
    "top_p": 0.8,
    "frequency_penalty": 0.1       # Direct OpenAI compatibility
}

# Google native (automatically translated)
{
    "temperature": 0.3,
    "max_output_tokens": 200,      # max_tokens → max_output_tokens
    "top_p": 0.8,
    "stop_sequences": ["END"],     # stop → stop_sequences (up to 5)
    "top_k": 40                    # Google-specific optimization
}

✨ Beneficios clave

Característica	Beneficio
🔄 Interfaz universal	Mismos parámetros en todos los proveedores
🎯 Seguridad de tipos	Validación Pydantic completa para salidas estructuradas
⚡ Rendimiento	Optimizaciones específicas del proveedor aplicadas automáticamente
🛡️ Fiabilidad	Retroceso elegante cuando fallan las salidas estructuradas
🔧 Mantenible	Separación limpia entre interfaz de usuario e implementación
🚀 A prueba de futuro	Fácil añadir nuevos proveedores siguiendo patrones establecidos

🧪 Probando tu configuración de proveedor

# Test parameter mapping
python -c "
from reactive_agents.providers.llm.ollama import OllamaModelProvider
provider = OllamaModelProvider('cogito:14b')
options = {'temperature': 0.2, 'max_tokens': 100}
print('OpenAI params:', provider.get_openai_params(options))
print('Native params:', provider.get_native_params(options))
"

# Integration testing across providers
python -m reactive_agents.tests.integration.diagnose_provider_issues

🎨 Uso avanzado

# Provider-specific optimizations while maintaining compatibility
builder = ReactiveAgentBuilder()

# Ollama with GPU acceleration
if provider == "ollama":
    builder.with_model_provider_options({
        "temperature": 0.2,
        "max_tokens": 1000,
        "num_gpu": 256,      # Ollama-specific: GPU layers
        "num_ctx": 8192,     # Ollama-specific: context window
    })

# Anthropic with advanced parameters
elif provider == "anthropic":
    builder.with_model_provider_options({
        "temperature": 0.2,
        "max_tokens": 1000,
        "top_k": 50,         # Anthropic-specific: top-k sampling
    })

# Google with structured schema
elif provider == "google":
    builder.with_model_provider_options({
        "temperature": 0.2,
        "max_tokens": 1000,
        "candidate_count": 3,    # Google-specific: multiple candidates
        "response_schema": schema # Google-specific: schema validation
    })

agent = await builder.build()

---

🧪 Área de pruebas y pruebas

El marco Reactive Agents incluye un área de pruebas integral para pruebas, experimentación y validación.

Inicio rápido con el área de pruebas

# Run basic functionality tests
poetry run python -m playground.runner agents

# Test reasoning strategies
poetry run python -m playground.runner strategies

# Stress test the framework
poetry run python -m playground.runner stress

# Run real-world scenarios
poetry run python -m playground.runner real-world

# List all available test suites
poetry run python -m playground.runner --list

¿Qué hay en el área de pruebas?

El área de pruebas proporciona:

• Pruebas de agentes - Validación de funcionalidad principal
• Pruebas de estrategias - Comparar enfoques de razonamiento
• Pruebas de estrés - Encontrar puntos de fallo y casos límite
• Pruebas del mundo real - Escenarios listos para producción
• Pruebas de memoria - Persistencia y aprendizaje
• Herramientas del sistema - Meta-acciones y control de agentes

Ejemplo de salida de prueba

$ poetry run python -m playground.runner agents

=== Running Agent Tests ===

✅ Basic agent creation: PASS (8.2s)
✅ Tool integration: PASS (12.5s)
✅ Event system: PASS (6.1s)
✅ Custom tools: PASS (9.8s)

4/4 tests passed in 36.6s

Para documentación completa del área de pruebas, consulta docs/playground.md

---

🔧 Herramientas e integraciones disponibles

🌐 Web y datos

• Búsqueda web - Brave Search, DuckDuckGo
• Extracción web - Automatización con Playwright
• APIs - Herramientas de cliente REST/GraphQL
• Procesamiento de datos - Integraciones con Pandas, NumPy

💾 Almacenamiento y bases de datos

• Sistema de archivos - Leer, escribir, organizar archivos
• SQLite - Operaciones y consultas de bases de datos
• Almacenes vectoriales - Integración con ChromaDB, Pinecone
• Almacenamiento en la nube - AWS S3, Google Cloud

🔧 Desarrollo y DevOps

• Operaciones Git - Gestión de repositorios
• Docker - Orquestación de contenedores
• CI/CD - GitHub Actions, Jenkins
• Monitoreo - Prometheus, Grafana

🤖 IA y ML

• Inferencia de modelos - Múltiples proveedores de LLM
• Embeddings - Embeddings de texto y multimodales
• Visión - Análisis y procesamiento de imágenes
• Voz - Capacidades TTS y STT

---

📈 Rendimiento y puntos de referencia

Reactive Agents está construido para rendimiento y escalabilidad:

Métrica	Resultado
Creación de agentes	< 100ms
Ejecución de herramientas	< 50ms de sobrecarga
Uso de memoria	< 100MB por agente
Agentes concurrentes	1000+ por instancia
Rendimiento	10,000+ tareas/hora

🚀 Características de optimización

• Carga diferida - Componentes cargados bajo demanda
• Agrupación de conexiones - Gestión eficiente de recursos
• Caché de contexto - Optimización inteligente de conversaciones
• Ejecución paralela - Ejecución de herramientas con múltiples hilos
• Gestión de memoria - Limpieza y optimización automáticas

---

🤝 Contribuciones

¡Nos encantan las contribuciones! Únete a nuestra creciente comunidad:

🎯 Contribución Rápida

1. Haz un fork del repositorio
2. Crea una rama de características: git checkout -b feature/amazing-feature
3. Haz commit de tus cambios: git commit -m 'Add amazing feature'
4. Haz push a la rama: git push origin feature/amazing-feature
5. Abre un Pull Request

🔧 Configuración de Desarrollo

# Clone and setup
git clone https://github.com/tylerjrbuell/reactive-agents
cd reactive-agents
poetry install

# Run tests
poetry run pytest

# Run with coverage
poetry run pytest --cov=reactive_agents

# Lint and format
poetry run black .
poetry run ruff check .

💬 Comunidad

Únete a la comunidad del proyecto en Discord para chatear, obtener soporte y colaborar:

• Invitación: https://discord.gg/WVxTnHt8

¡Damos la bienvenida a contribuyentes, usuarios y mantenedores! Pasa, preséntate y cuéntanos qué estás construyendo con Reactive Agents!

📝 Áreas de Contribución

• 🧠 Nuevas Estrategias de Razonamiento
• 🔧 Integraciones de Herramientas
• 📚 Documentación y Ejemplos
• 🐛 Correcciones de Errores y Rendimiento
• 🎨 Mejoras de UI/UX
• 🌍 Internacionalización

---

📊 Estadísticas del Proyecto

---

🙏 Agradecimientos

Construido con amor usando estas increíbles tecnologías:

• Pydantic - Validación de datos y configuración
• FastAPI - Framework web moderno
• asyncio - Programación asíncrona
• Model Context Protocol - Estándar de integración de herramientas
• Poetry - Gestión de dependencias

¡Un agradecimiento especial a nuestros increíbles contribuyentes y a la comunidad de IA! 🚀

---

📄 Licencia

Este proyecto está bajo la Licencia MIT - consulta el archivo LICENCIA para más detalles.

---