Reactive AI Agent Framework

Um framework de agente de IA reativo para criar agentes que usam ferramentas para realizar tarefas, com suporte para múltiplos provedores de LLM e servidores MCP.

GitHub

Experimente este MCPPatrocinado

Documentação

🚀 Reactive AI Agent Framework

Um Framework Elegante, Poderoso e Flexível para Construir Agentes de IA Reativos

🏁 Início Rápido • 📖 Documentação • 🎯 Recursos • 🛠️ Instalação • 💡 Exemplos • 🤝 Contribuição

🌟 O que são Agentes Reativos?

Agentes Reativos é um framework de agentes de IA de ponta que torna a construção de agentes inteligentes e autônomos tão simples quanto o Laravel torna o desenvolvimento web. Com seu elegante padrão de construção (builder pattern), ecossistema abrangente de ferramentas e arquitetura pronta para produção, você pode criar agentes de IA sofisticados que pensam, planejam, executam e se adaptam.

🔎 Definição — "Reativo" (adj.)

reativo /ʁe.aˈt͡ʃi.vu/

Prontamente responsivo a mudanças ou estímulos externos; capaz de sentir, interpretar e agir em tempo real.
Arquitetado para ciclos de feedback rápidos, adaptação consciente do contexto e tomada de decisão de baixa latência.

🚀 Por que "Reativo"?

Agentes reativos transformam a percepção em valor instantâneo — eles detectam mudanças, acionam as ferramentas certas e ajustam planos em tempo real. Isso significa respostas mais rápidas, menos falhas, melhores experiências de usuário e sistemas que escalam com elegância sob incertezas do mundo real. Em resumo: reativo = IA mais rápida, mais inteligente e mais confiável que gera resultados confiáveis agora.

🎯 Perfeito Para

🔬 Automação de Pesquisa - Pesquisa web inteligente e análise de dados
📊 Inteligência de Negócios - Relatórios automatizados e suporte à decisão
🛠️ DevOps e Infraestrutura - Monitoramento e automação inteligentes
💬 Suporte ao Cliente - Assistentes inteligentes com integração de ferramentas
📈 Processamento de Dados - Fluxos de trabalho complexos com múltiplas fontes de dados
🎮 Aplicações Interativas - Experiências de usuário com IA
🤖 Sistemas Multiagentes - Equipes de IA orquestradas resolvendo problemas complexos
⚙️ Automação e Scripts - Automação inteligente de tarefas

✨ Recursos Principais

🧠 Múltiplas Estratégias de Raciocínio

Estratégias compostas com arquitetura baseada em componentes: As estratégias são modulares e plugáveis, construídas a partir de componentes discretos (planejadores, executores, refletores e avaliadores de metas) que você pode combinar para criar fluxos de raciocínio personalizados.

Componentes modulares — planejadores, executores, refletores e avaliadores são independentes e substituíveis.
Estratégias plugáveis — implemente BaseReasoningStrategy e registre com StrategyManager para adicionar novas estratégias.
Testáveis e reutilizáveis — componentes pequenos e bem tipados tornam os testes unitários e a reutilização simples.
Projetado para composição — use a estratégia Adaptativa ou componha múltiplas estratégias para lidar com tarefas complexas e dinâmicas.

Estratégias pré-construídas incluem:

Reativa: Resolução de problemas rápida e direta
Planejar-Executar-Refletir: Abordagem estruturada para tarefas complexas
Refletir-Decidir-Agir: Estratégia adaptativa para ambientes dinâmicos
Adaptativa: Seleção de estratégia orientada por IA com base na complexidade da tarefa

🔧 Ecossistema Abrangente de Ferramentas

Ferramentas Python Personalizadas com o decorador @tool()
Integração com Model Context Protocol (MCP)
Ferramentas Pré-construídas: Pesquisa web, operações de arquivo, bancos de dados e mais
Composição de Ferramentas e sistema de validação

🏗️ Arquitetura Pronta para Produção

Design Orientado a Eventos com monitoramento em tempo real
Recuperação Robusta de Erros com mecanismos inteligentes de nova tentativa
Gerenciamento de Memória com armazenamento vetorial e persistência
Monitoramento de Desempenho com métricas detalhadas e pontuação
Otimização de Contexto com estratégias adaptativas de poda

🔄 Gerenciamento Avançado de Fluxos de Trabalho

Orquestração Multiagente com gerenciamento de dependências
Protocolos de Comunicação A2A (Agente para Agente)
Execução Paralela e sincronização
Modelos de Fluxo de Trabalho para padrões comuns

🎛️ Experiência do Desenvolvedor

API de Construção Fluente com padrões sensatos
Segurança de Tipos com modelos Pydantic em todo o framework
Registro Abrangente com eventos estruturados
🚧 Sistema de Plugins para extensibilidade
Recarga a quente para fluxos de trabalho de desenvolvimento

🏁 Início Rápido

Instalação

pip install reactive-agents

Seu Primeiro 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())

É isso! Agora você tem um agente de IA totalmente funcional que pode pesquisar na web, analisar informações e fornecer respostas abrangentes.

🎯 Conceitos Principais

🤖 Arquitetura do Agente

Agentes Reativos usa uma arquitetura baseada em componentes onde cada agente é composto por componentes especializados e substituíveis:

# 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

🧭 Estratégias de Raciocínio

Escolha a estratégia certa para sua tarefa:

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

🛠️ Integração de Ferramentas

Múltiplas maneiras de adicionar capacidades aos seus 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])

💡 Exemplos

🔍 Agente de Pesquisa 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 Inteligência de Negócios

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()
    )

🔄 Fluxo de Trabalho 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

🎛️ Monitoramento Orientado a 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()
    )

🛠️ Instalação e Configuração

Pré-requisitos

Python 3.10+
Poetry (recomendado) ou pip

Instalação Básica

# Using pip
pip install reactive-agents

# Using Poetry
poetry add reactive-agents

Instalação para Desenvolvimento

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

# Install with Poetry
poetry install

# Run tests
poetry run pytest

Configuração de Ambiente

Crie um arquivo .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

🎯 Recursos Avançados

🧠 Estratégias de Raciocínio Personalizadas

Implemente sua própria abordagem de raciocínio:

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")

🔧 Criação de Ferramentas Personalizadas

Construa ferramentas sofisticadas com validação:

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
    }

📊 Monitoramento de Desempenho

Acompanhe e otimize o desempenho do agente:

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 Plugins 🚧

Estenda o framework com plugins:

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())

📖 Documentação

📚 Guias Abrangentes

Guia de Introdução - Seu primeiro agente em 5 minutos
Visão Geral da Arquitetura - Entendendo o framework
Desenvolvimento de Ferramentas - Construindo ferramentas e integrações personalizadas
Estratégias de Raciocínio - Aprofundamento no raciocínio de IA
Orquestração de Fluxos de Trabalho - Coordenação multiagente
Implantação em Produção - Escalando para produção

🔧 Referência da API

API do Construtor de Agentes - Referência completa do padrão de construção
API do Sistema de Ferramentas - Registro e execução de ferramentas
API do Sistema de Eventos - Monitoramento em tempo real e hooks
API de Configuração - Opções avançadas de configuração

💡 Exemplos e Tutoriais

Galeria de Exemplos - Mais de 20 exemplos do mundo real
Série de Tutoriais - Caminho de aprendizado passo a passo
Melhores Práticas - Dicas e padrões de produção
Solução de Problemas - Problemas comuns e soluções

🌐 Suporte a Provedores de Modelos

Agentes Reativos funciona com todos os principais provedores de LLM:

Provedor	Modelos	Recursos
OpenAI	GPT-4o, GPT-4, GPT-3.5	Chamada de funções, streaming, visão
Anthropic	Claude 3.5 Sonnet, Claude 3	Contexto grande, uso de ferramentas
Groq	Llama 3, Mixtral	Inferência ultra-rápida
Ollama	Qualquer modelo local	Privacidade, personalização
Google	Gemini Pro, Gemini Flash	Capacidades multimodais

Atualização v0.1.0a7: O provedor Google agora usa o SDK google-genai mais recente (v1.5.0) com desempenho aprimorado e zero avisos de depreciação.

# 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

🎯 Saídas Estruturadas e Arquitetura de Provedores

🔄 Sistema Universal de Saídas Estruturadas

Agentes Reativos implementa um sistema unificado de saídas estruturadas usando o Pacote Python Instructor em todos os provedores de modelos. Isso garante validação consistente de modelos Pydantic e segurança de tipos independentemente da sua escolha de LLM.

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

🔧 Interface de Parâmetros no Estilo OpenAI

O framework usa parâmetros compatíveis com OpenAI como interface padrão, com tradução automática para formatos específicos do provedor:

# ✅ 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...")

🔄 Arquitetura de Parâmetros Duplos

O framework usa um elegante sistema de parâmetros duplos:

1️⃣ Camada de Interface do Usuário (estilo OpenAI)

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

2️⃣ Camada de Otimização do Provedor (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
}

✨ Principais Benefícios

Recurso	Benefício
🔄 Interface Universal	Mesmos parâmetros em todos os provedores
🎯 Segurança de Tipos	Validação Pydantic completa para saídas estruturadas
⚡ Desempenho	Otimizações específicas do provedor aplicadas automaticamente
🛡️ Confiabilidade	Fallback elegante quando saídas estruturadas falham
🔧 Manutenível	Separação clara entre interface do usuário e implementação
🚀 À Prova do Futuro	Fácil adicionar novos provedores seguindo padrões estabelecidos

🧪 Testando a Configuração do Seu Provedor

# 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 Avançado

# 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()

🧪 Playground e Testes

O framework Agentes Reativos inclui um playground abrangente para testes, experimentação e validação.

Início Rápido com o Playground

# 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

O que há no Playground?

O playground fornece:

Testes de Agentes - Validação da funcionalidade principal
Testes de Estratégias - Compare abordagens de raciocínio
Testes de Estresse - Encontre pontos de falha e casos extremos
Testes do Mundo Real - Cenários prontos para produção
Testes de Memória - Persistência e aprendizado
Ferramentas do Sistema - Meta-ações e controle do agente

Exemplo de Saída de Teste

$ 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 documentação completa do playground, consulte docs/playground.md

🔧 Ferramentas e Integrações Disponíveis

🌐 Web e Dados

Pesquisa Web - Brave Search, DuckDuckGo
Raspagem Web - Automação com Playwright
APIs - Ferramentas de cliente REST/GraphQL
Processamento de Dados - Integrações com Pandas, NumPy

💾 Armazenamento e Bancos de Dados

Sistema de Arquivos - Ler, escrever, organizar arquivos
SQLite - Operações e consultas de banco de dados
Armazenamentos Vetoriais - Integração com ChromaDB, Pinecone
Armazenamento em Nuvem - AWS S3, Google Cloud

🔧 Desenvolvimento e DevOps

Operações Git - Gerenciamento de repositórios
Docker - Orquestração de contêineres
CI/CD - GitHub Actions, Jenkins
Monitoramento - Prometheus, Grafana

🤖 IA e ML

Inferência de Modelos - Múltiplos provedores de LLM
Embeddings - Embeddings de texto e multimodais
Visão - Análise e processamento de imagens
Fala - Capacidades de TTS e STT

📈 Desempenho e Benchmarks

Agentes Reativos é construído para desempenho e escalabilidade:

Métrica	Resultado
Criação de Agente	< 100ms
Execução de Ferramenta	< 50ms de overhead
Uso de Memória	< 100MB por agente
Agentes Concorrentes	1000+ por instância
Taxa de Transferência	10.000+ tarefas/hora

🚀 Recursos de Otimização

Carregamento Preguiçoso - Componentes carregados sob demanda
Pooling de Conexões - Gerenciamento eficiente de recursos
Cache de Contexto - Otimização inteligente de conversas
Execução Paralela - Execução de ferramentas com múltiplas threads
Gerenciamento de Memória - Limpeza e otimização automáticas

🤝 Contribuição

Adoramos contribuições! Junte-se à nossa comunidade em crescimento:

🎯 Contribuição Rápida

Faça um fork do repositório
Crie um branch de funcionalidade: git checkout -b feature/amazing-feature
Faça commit das suas alterações: git commit -m 'Add amazing feature'
Envie para o branch: git push origin feature/amazing-feature
Abra um Pull Request

🔧 Configuração de Desenvolvimento

# 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 .

💬 Comunidade

Junte-se à comunidade do projeto no Discord para conversar, obter suporte e colaborar:

Convite: https://discord.gg/WVxTnHt8

Recebemos contribuidores, usuários e mantenedores — passe por lá, apresente-se e conte-nos o que você está construindo com Reactive Agents!

📝 Áreas de Contribuição

🧠 Novas Estratégias de Raciocínio
🔧 Integrações de Ferramentas
📚 Documentação e Exemplos
🐛 Correções de Bugs e Performance
🎨 Melhorias de UI/UX
🌍 Internacionalização

📊 Estatísticas do Projeto

PyPI downloads GitHub issues GitHub pull requests

🙏 Agradecimentos

Construído com amor usando estas tecnologias incríveis:

Pydantic - Validação de dados e configurações
FastAPI - Framework web moderno
asyncio - Programação assíncrona
Model Context Protocol - Padrão de integração de ferramentas
Poetry - Gerenciamento de dependências

Agradecimentos especiais aos nossos incríveis contribuidores e à comunidade de IA! 🚀

📄 Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para mais detalhes.

Pronto para construir o futuro com agentes de IA?

⭐ Dê uma estrela neste repositório se você o achar útil!
🐛 Reporte problemas para nos ajudar a melhorar
💬 Junte-se à nossa comunidade para suporte e discussões

🚀 Comece Agora | 📖 Leia a Documentação | 💬 Entre no Discord

Feito com ❤️ pela equipe Reactive Agents