Sistema multi-agente com RAG para analise inteligente de cardapios de restaurantes.

Acesse o demo ao vivo →

O SaborAI responde perguntas sobre cardapios de restaurantes usando uma arquitetura multi-agente com RAG. Um agente supervisor roteia cada query para um ou mais agentes especialistas, agrega as respostas e entrega um resultado estruturado.

Casos de uso:

• "Quais pratos sao adequados para veganos com intolerancia a gluten?"
• "Monte um combo completo por ate R$60 para um casal."
• "Avalie a qualidade das descricoes do cardapio e sugira melhorias para aumentar a conversao."

Query do Usuario
      |
      v
SupervisorAgent  <- roteamento via LLM (GPT-4o-mini)
      |
      |---> NutritionAgent       (restricoes alimentares, alergenicos, calorias)
      |---> RecommendationAgent  (combos, filtro por budget, harmonizacoes)       } asyncio.gather
      \---> QualityAgent         (score de qualidade descritiva, conversao)       } (paralelo)
               |
               v
         ChromaDB (vector store local)
               ^
               |
      Pipeline de Ingestao
      (PDF/TXT -> chunking -> deduplicacao -> embedding -> persist)

O suite de evals mede 4 dimensoes por caso de teste:

Os resultados sao persistidos em data/eval_results/ como JSON com timestamp para rastreamento de experimentos.

Painel Streamlit para visualizacao interativa de metricas:

streamlit run dashboard.py

Funcionalidades:

• Metricas agregadas do ultimo run com delta vs run anterior
• Drill-down por caso de teste
• Grafico radar de scores por caso
• Trends de metricas ao longo do tempo
• Execucao de novas avaliacoes via UI

Script que gera cardapios realistas via LLM para aumentar a cobertura de dados:

# Gerar 5 cardapios de cuisines diversas
python -m scripts.generate_synthetic_menus --count 5

# Gerar para cozinha especifica e ingerir automaticamente
python -m scripts.generate_synthetic_menus --cuisine Japonesa --count 2 --ingest

# Gerar faixa premium
python -m scripts.generate_synthetic_menus --price-tier premium --count 3 --output data/sample_menus/

O script gera um manifesto JSON com metadata (Pydantic) para rastreamento de qualidade dos dados gerados.

Documentacao interativa disponivel em http://localhost:8000/docs (Swagger UI).

git clone https://github.com/nikolasdehor/CardapIA.git
cd CardapIA
cp .env.example .env
# Adicione sua OPENAI_API_KEY no .env

docker compose up --build
# API: http://localhost:8000/docs
# Dashboard: http://localhost:8501

python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
uvicorn api.main:app --reload

curl -X POST http://localhost:8000/ingest/file \
  -F "file=@data/sample_menus/bella_terra.txt" \
  -F "menu_name=Bella Terra"

# Recomendacao com budget
curl -X POST http://localhost:8000/query \
  -H "Content-Type: application/json" \
  -d '{"query": "Monte um combo completo por ate R$60 para um casal vegano."}'

# Avaliacao de qualidade
curl -X POST http://localhost:8000/query \
  -H "Content-Type: application/json" \
  -d '{"query": "Avalie a qualidade das descricoes do cardapio e sugira melhorias."}'

# Restricoes alimentares
curl -X POST http://localhost:8000/query \
  -H "Content-Type: application/json" \
  -d '{"query": "Quais pratos nao contem gluten nem laticinios?"}'

python -m scripts.generate_synthetic_menus --count 3 --ingest

curl -X POST http://localhost:8000/evaluate \
  -H "Content-Type: application/json" \
  -d '{"suite": "default"}'

streamlit run dashboard.py

• Runtime: Python 3.11
• API: FastAPI + Uvicorn
• Orquestracao LLM: LangChain (agents, RAG, prompts)
• LLM: OpenAI GPT-4o-mini
• Embeddings: OpenAI text-embedding-3-small
• Vector Store: ChromaDB (persistencia local)
• Dashboard: Streamlit + Plotly
• Containerizacao: Docker + Docker Compose
• CI/CD: GitHub Actions (lint, test, build, deploy)

CardapIA/
├── agents/
│   ├── supervisor.py              # Roteamento, consolidacao e execucao paralela
│   ├── nutrition.py               # Especialista em dietas e alergenicos
│   ├── recommendation.py         # Especialista em combos e harmonizacoes
│   ├── quality.py                 # Especialista em qualidade e conversao
│   └── retry.py                   # Retry com exponential backoff (sync + async)
├── api/
│   ├── main.py                    # App FastAPI e endpoints (incl. SSE streaming)
│   ├── settings.py                # Configuracao via Pydantic-settings
│   └── middleware.py              # Logging estruturado e request tracking
├── ingestion/
│   └── pipeline.py                # Load -> chunk -> deduplica -> embed
├── evals/
│   └── runner.py                  # Framework LLM-as-judge
├── experiments/
│   └── compare_models.py         # Experimentacao comparativa de modelos/configs
├── scripts/
│   └── generate_synthetic_menus.py  # Geracao de dados sinteticos via LLM
├── data/
│   ├── sample_menus/              # Cardapios de exemplo e sinteticos
│   ├── eval_results/              # Resultados de avaliacoes
│   └── experiment_results/        # Resultados de experimentos
├── tests/
│   ├── conftest.py                # Fixtures e configuracao de testes
│   ├── test_api.py                # Testes de integracao (API endpoints)
│   ├── test_agents.py             # Testes de inicializacao e configuracao
│   ├── test_supervisor.py         # Testes de routing e orquestracao
│   ├── test_pipeline.py           # Testes do pipeline de ingestao
│   └── test_retry.py             # Testes do modulo de retry
├── .github/
│   └── workflows/
│       ├── ci.yml                 # Lint, test, build Docker
│       └── cd.yml                 # Deploy staging/production
├── dashboard.py                   # Dashboard Streamlit de evals
├── Dockerfile
├── docker-compose.yml
├── requirements.txt
└── pyproject.toml

O pipeline de CI/CD roda no GitHub Actions:

CI (ci.yml):

1. Lint & Format — Ruff check + format
2. Tests — Unit tests (sem API key)
3. Build Docker — Build e push para GitHub Container Registry
4. Integration Tests — Testes com API key real (apenas na main)

CD (cd.yml):

1. Build Release — Imagem com tag semver
2. Deploy Staging — Deploy automatico
3. Smoke Tests & Evals — Health check + eval suite no staging
4. Deploy Production — Apenas apos smoke tests passarem

Script para rodar experimentos comparativos entre modelos, temperaturas e tamanhos de chunk:

# Comparar GPT-4o-mini vs GPT-4o com diferentes temperaturas
python -m experiments.compare_models --models gpt-4o-mini gpt-4o --temperatures 0 0.2 0.5

# Comparar diferentes chunk sizes
python -m experiments.compare_models --chunk-sizes 512 1024 2048

Resultados salvos em data/experiment_results/ com metricas de relevancia, coerencia, completude, cobertura de keywords e latencia por configuracao.

• Logging estruturado (JSON): Cada request carrega um X-Request-ID unico, e todos os logs sao emitidos como JSON lines (compativeis com Loki, CloudWatch, etc.).
• Metricas por request: Header X-Response-Time-Ms em toda resposta.
• Retry com backoff: Chamadas a OpenAI com ate 3 retries automaticos com exponential backoff e jitter para lidar com rate limits e erros transientes.

• Sistema multi-agente com RAG (Supervisor + 3 especialistas)
• Pipeline de ingestao com deduplicacao
• Framework de avaliacao LLM-as-judge
• Geracao de dados sinteticos via LLM
• Dashboard de evals (Streamlit)
• CI/CD com GitHub Actions
• Execucao assincrona dos agentes (chamadas paralelas via asyncio.gather)
• Streaming de respostas via SSE (/query/stream)
• Retry com exponential backoff nas chamadas OpenAI
• Logging estruturado (JSON) com request tracking
• Framework de experimentacao comparativa de LLMs
• Suporte a cardapios em imagem (vision + OCR)
• Suporte multilingue

PRs sao bem-vindos! Abra uma issue descrevendo o que deseja implementar antes de comecar.

MIT