使用说明

🚀 Guia Completo - Sistema RAG Multi-Agentes com Quarkus

📋 Índice

Visão Geral
Pré-requisitos
Configuração Inicial
Estrutura do Projeto
Iniciando o Projeto
Endpoints e Testes
Arquitetura Multi-Agentes
Pré-processamento de Texto para Embeddings
Cenário de Teste Completo
Troubleshooting

🎯 Visão Geral

Este projeto implementa um sistema RAG (Retrieval-Augmented Generation) com múltiplos agentes de IA usando Quarkus, LangChain4j e PostgreSQL com pgvector. O sistema oferece duas abordagens diferentes para orquestração de agentes:

LangChain4j Puro: Implementação direta com LangChain4j
MCP + gRPC: Protocolo estruturado com comunicação gRPC entre agentes

Funcionalidades Principais

📄 Upload e indexação de documentos (TXT, PDF, etc.)
🤖 Chat com IA usando RAG (busca semântica + LLM)
👥 Sistema multi-agentes com 4 agentes especializados
🔄 Comparação de abordagens (LangChain4j vs MCP+gRPC)
🗄️ Armazenamento vetorial com PostgreSQL + pgvector

📦 Pré-requisitos

Software Necessário

☕ Java 17 ou superior
🐳 Docker e Docker Compose
📦 Maven 3.8+
🔧 Git (opcional)

Verificar Instalação

# Verificar Java
java -version

# Verificar Maven
mvn -version

# Verificar Docker
docker --version
docker-compose --version

⚙️ Configuração Inicial

Passo 1: Clonar/Acessar o Projeto

cd C:\Users\solan\Desktop\QUARKUS-MCP

Passo 2: Configurar Variáveis de Ambiente

Crie um arquivo .env na raiz do projeto (ou configure as variáveis no application.properties):

# OpenAI API Key (obrigatório)
QUARKUS_LANGCHAIN4J_OPENAI_API_KEY=sk-sua-chave-aqui

# Configuração do Banco de Dados
QUARKUS_DATASOURCE_USERNAME=postgres
QUARKUS_DATASOURCE_PASSWORD=postgres
QUARKUS_DATASOURCE_JDBC_URL=jdbc:postgresql://localhost:5432/ragdb

# Porta da Aplicação
QUARKUS_HTTP_PORT=8080

Passo 3: Subir o Banco de Dados PostgreSQL

O projeto usa PostgreSQL com a extensão pgvector para armazenamento de embeddings.

# Iniciar o Docker Compose (PostgreSQL + pgvector)
docker-compose up -d

# Verificar se o container está rodando
docker ps

# Ver logs do banco
docker-compose logs -f postgres

Aguarde alguns segundos para o banco inicializar completamente.

Passo 4: Verificar Estrutura do Banco

O banco de dados será criado automaticamente pelo Quarkus com as seguintes tabelas:

documents: Metadados dos documentos
embeddings: Vetores de embeddings para busca semântica

📂 Estrutura do Projeto

QUARKUS-MCP/
├── src/
│   └── main/
│       ├── java/com/quarkus/rag/
│       │   ├── controller/        # Controllers REST (MVC)
│       │   │   ├── ChatController.java
│       │   │   ├── DocumentController.java
│       │   │   ├── AgentController.java
│       │   │   └── MCPComparisonController.java
│       │   ├── dto/               # Data Transfer Objects
│       │   │   ├── chat/          # DTOs de Chat
│       │   │   │   ├── ChatRequest.java
│       │   │   │   └── ChatResponse.java
│       │   │   ├── agent/         # DTOs de Agentes
│       │   │   │   ├── AgentRequest.java
│       │   │   │   ├── SimpleResponse.java
│       │   │   │   └── AnalyzeRequest.java
│       │   │   ├── mcp/           # DTOs de MCP/Comparação
│       │   │   │   ├── MCPRequest.java
│       │   │   │   ├── ComparisonResponse.java
│       │   │   │   ├── ApproachResult.java
│       │   │   │   ├── ComparisonMetrics.java
│       │   │   │   ├── BenchmarkRequest.java
│       │   │   │   ├── BenchmarkResponse.java
│       │   │   │   ├── ApproachInfo.java
│       │   │   │   └── ApproachDetails.java
│       │   │   └── document/      # DTOs de Documentos (futuro)
│       │   ├── service/           # Lógica de negócio
│       │   │   ├── RagService.java
│       │   │   ├── DocumentIngestionService.java
│       │   │   └── MultiAgentOrchestrator.java
│       │   ├── ai/                # Agentes de IA
│       │   │   ├── ChatService.java
│       │   │   └── agents/
│       │   │       ├── CoordinatorAgent.java
│       │   │       ├── DocumentAnalystAgent.java
│       │   │       ├── TechnicalExpertAgent.java
│       │   │       └── ValidatorAgent.java
│       │   ├── mcp/               # MCP + gRPC
│       │   │   └── service/
│       │   ├── entity/            # Entidades JPA
│       │   └── repository/        # Repositórios
│       ├── proto/                 # Definições gRPC
│       └── resources/
│           └── application.properties
├── documents/                     # Documentos de exemplo
├── docker-compose.yml
├── pom.xml
└── GUIA-COMPLETO.md              # Este arquivo

🚀 Iniciando o Projeto

Modo Desenvolvimento (Dev Mode)

# Compilar e iniciar em modo desenvolvimento
mvn quarkus:dev

Vantagens do Dev Mode:

♻️ Hot reload automático
🐛 Debug facilitado
🔧 Configuração dinâmica

Modo Produção

# Compilar o projeto
mvn clean package

# Executar o JAR
java -jar target/quarkus-app/quarkus-run.jar

Verificar se a Aplicação Está Rodando

# Testar endpoint de saúde
curl http://localhost:8080/q/health

# Deve retornar status UP

🧪 Endpoints e Testes

1. 📄 Gerenciamento de Documentos

1.1 Upload de Documento

Faz upload de um arquivo para indexação no sistema RAG.

Endpoint: POST /api/documents/upload

# Exemplo com arquivo TXT
curl -X POST http://localhost:8080/api/documents/upload \
  -F "file=@C:\Users\solan\Desktop\QUARKUS-MCP\documents\Sobre.txt"

# Exemplo com arquivo PDF
curl -X POST http://localhost:8080/api/documents/upload \
  -F "file=@C:\caminho\para\seu\arquivo.pdf"

Resposta de Sucesso:

{
  "id": 1,
  "fileName": "Sobre.txt",
  "contentType": "text/plain",
  "fileSize": 1024,
  "uploadedAt": "2025-10-20T10:30:00",
  "processed": true
}

1.2 Listar Todos os Documentos

Lista todos os documentos carregados no sistema.

Endpoint: GET /api/documents

curl http://localhost:8080/api/documents

Resposta:

[
  {
    "id": 1,
    "fileName": "Sobre.txt",
    "contentType": "text/plain",
    "fileSize": 1024,
    "uploadedAt": "2025-10-20T10:30:00",
    "processed": true
  },
  {
    "id": 2,
    "fileName": "FAQ.txt",
    "contentType": "text/plain",
    "fileSize": 2048,
    "uploadedAt": "2025-10-20T11:00:00",
    "processed": true
  }
]

1.3 Buscar Documento por ID

Obtém detalhes de um documento específico.

Endpoint: GET /api/documents/{id}

curl http://localhost:8080/api/documents/1

1.4 Deletar Documento

Remove um documento do sistema.

Endpoint: DELETE /api/documents/{id}

curl -X DELETE http://localhost:8080/api/documents/1

Resposta: Status 204 (No Content) em caso de sucesso.

2. 💬 Chat Simples (RAG Básico)

Chat básico usando RAG sem multi-agentes.

Endpoint: POST /api/chat

# Pergunta simples
curl -X POST http://localhost:8080/api/chat \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"O que é a empresa?\"}"

# Com limite de resultados customizado
curl -X POST http://localhost:8080/api/chat \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Quais são os planos disponíveis?\", \"maxResults\": 3}"

Resposta:

{
  "answer": "A empresa é uma plataforma de inovação focada em sustentabilidade..."
}

3. 🤖 Multi-Agentes (LangChain4j)

Sistema avançado com 4 agentes especializados trabalhando em pipeline.

3.1 Pergunta com Multi-Agentes (Resposta Completa)

Retorna todas as etapas do processamento multi-agente.

Endpoint: POST /api/agents/ask

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como funciona a segurança da plataforma?\"}"

Resposta Completa:

{
  "question": "Como funciona a segurança da plataforma?",
  "documentAnalysis": "Análise do DocumentAnalystAgent: Os documentos relevantes indicam...",
  "technicalAnswer": "Resposta do TechnicalExpertAgent: A plataforma utiliza criptografia...",
  "validation": "Validação do ValidatorAgent: A resposta está correta e completa...",
  "finalAnswer": "Resposta final do CoordinatorAgent: A segurança da plataforma...",
  "agentsUsed": ["DocumentAnalyst", "TechnicalExpert", "Validator", "Coordinator"],
  "processingTimeMs": 2500
}

3.2 Pergunta Simplificada (Apenas Resposta Final)

Retorna apenas a resposta final sem etapas intermediárias.

Endpoint: POST /api/agents/ask-simple

curl -X POST http://localhost:8080/api/agents/ask-simple \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Qual o custo dos planos?\"}"

Resposta:

{
  "answer": "Os planos estão disponíveis em três categorias: Básico (R$ 29,90), Premium (R$ 79,90) e Enterprise (valor personalizado)..."
}

3.3 Análise de Documento

Analisa um texto usando múltiplos agentes.

Endpoint: POST /api/agents/analyze

curl -X POST http://localhost:8080/api/agents/analyze \
  -H "Content-Type: application/json" \
  -d "{\"content\": \"Nossa plataforma oferece soluções inovadoras em sustentabilidade...\"}"

Resposta:

{
  "summary": "Resumo gerado pelo DocumentAnalyst...",
  "technicalInsights": "Insights técnicos identificados...",
  "validationNotes": "Pontos de validação...",
  "overallAssessment": "Avaliação geral do documento..."
}

4. 🔄 MCP + gRPC (Protocolo Estruturado)

Abordagem alternativa usando MCP (Model Context Protocol) com gRPC.

4.1 Pergunta com MCP

Processa pergunta usando protocolo MCP.

Endpoint: POST /api/mcp/ask

curl -X POST http://localhost:8080/api/mcp/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como entrar em contato com o suporte?\"}"

Resposta:

{
  "finalAnswer": "Você pode entrar em contato com o suporte através...",
  "documentAnalysis": "Análise via MCP...",
  "technicalAnswer": "Resposta técnica via MCP...",
  "validation": "Validação via MCP...",
  "protocol": "MCP+gRPC",
  "processingTimeMs": 2100
}

4.2 Comparação de Abordagens

Compara LangChain4j puro vs MCP+gRPC lado a lado.

Endpoint: POST /api/mcp/compare

curl -X POST http://localhost:8080/api/mcp/compare \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Quais são as funcionalidades principais?\"}"

Resposta Comparativa:

{
  "langchain4jResult": {
    "approach": "LangChain4j Pure",
    "finalAnswer": "As funcionalidades principais incluem...",
    "documentAnalysis": "...",
    "technicalAnswer": "...",
    "validation": "...",
    "processingTimeMs": 2500,
    "error": null
  },
  "mcpResult": {
    "approach": "MCP + gRPC",
    "finalAnswer": "As funcionalidades principais incluem...",
    "documentAnalysis": "...",
    "technicalAnswer": "...",
    "validation": "...",
    "processingTimeMs": 2100,
    "error": null
  },
  "metrics": {
    "langchainDuration": 2500,
    "mcpDuration": 2100,
    "faster": "MCP+gRPC",
    "percentageDifference": 16.0
  }
}

👥 Arquitetura Multi-Agentes

Os 4 Agentes Especializados

1. 📊 DocumentAnalystAgent

Função: Analisa documentos recuperados do RAG
Responsabilidade: Extrair informações relevantes e contexto
Output: Análise estruturada dos documentos

2. 🔧 TechnicalExpertAgent

Função: Responde perguntas técnicas especializadas
Responsabilidade: Fornecer respostas detalhadas e técnicas
Output: Resposta técnica fundamentada

3. ✅ ValidatorAgent

Função: Valida a qualidade das respostas
Responsabilidade: Verificar precisão, completude e consistência
Output: Relatório de validação

4. 🎯 CoordinatorAgent

Função: Coordena todos os agentes e gera resposta final
Responsabilidade: Sintetizar informações e apresentar resposta coerente
Output: Resposta final consolidada

Pipeline de Processamento

Pergunta do Usuário
        ↓
[1] RAG - Busca Semântica
        ↓
[2] DocumentAnalystAgent → Analisa documentos recuperados
        ↓
[3] TechnicalExpertAgent → Gera resposta técnica
        ↓
[4] ValidatorAgent → Valida a resposta
        ↓
[5] CoordinatorAgent → Sintetiza resposta final
        ↓
Resposta ao Usuário

📝 Pré-processamento de Texto para Embeddings

📋 Visão Geral

O sistema implementa um robusto processo de pré-processamento de texto usando Apache Lucene 9.9.2, uma das bibliotecas mais utilizadas no mercado para análise e processamento de texto. Esse componente é essencial para garantir a qualidade dos embeddings e melhorar a precisão das buscas semânticas.

🚀 Funcionalidades Implementadas

TextPreprocessingService

Serviço centralizado que aplica todas as transformações necessárias para melhorar a qualidade dos embeddings antes de serem criados.

Transformações Aplicadas:

Garantia de UTF-8
- Converte e valida que todo texto está em UTF-8
- Previne problemas de encoding
Remoção de HTML Tags
- Remove tags HTML que podem estar presentes nos documentos
- Limpa o texto mantendo apenas conteúdo relevante
Normalização de Caracteres
- Normaliza caracteres Unicode (forma NFC)
- Mantém acentos (importante para português)
- Remove caracteres especiais problemáticos
Normalização de Espaços
- Remove múltiplos espaços consecutivos
- Normaliza tabs e quebras de linha
- Limpa espaços no início e fim
Análise Lucene para Português (BrazilianAnalyzer)
- Lowercase: Converte todo texto para minúsculas
- Remoção de Stopwords: Remove palavras comuns em português (de, da, o, a, para, etc.)
- Stemming: Reduz palavras à raiz (correndo → corr, corrida → corr)
- Tokenização: Quebra o texto em tokens relevantes
- Filtro de tamanho mínimo: Remove tokens muito pequenos (< 2 caracteres)

🔄 Integração no Sistema

1. DocumentIngestionService

O pré-processamento é aplicado durante a ingestão de documentos:

// Pré-processa documentos antes de criar embeddings
String preprocessedText = textPreprocessingService.preprocessForEmbedding(originalText);

Fluxo:

Parser lê o documento (PDF, DOCX, TXT)
Texto é pré-processado e limpo
Validação de qualidade do texto
Documento processado é dividido em segmentos
Embeddings são criados com texto de qualidade

2. RagService

O pré-processamento também é aplicado às perguntas dos usuários:

// Pré-processa a pergunta do usuário
String processedQuestion = textPreprocessingService.preprocessForQuery(question);

Fluxo:

Pergunta do usuário é pré-processada
Busca no banco vetorial usa texto processado
Melhora a similaridade entre pergunta e documentos
Resposta usa pergunta original (melhor contexto para LLM)

📦 Dependências Adicionadas

As seguintes dependências foram incluídas no pom.xml:

<!-- Apache Lucene for Text Processing -->
<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-core</artifactId>
    <version>9.9.2</version>
</dependency>
<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-analysis-common</artifactId>
    <version>9.9.2</version>
</dependency>

🎯 Benefícios

Qualidade dos Embeddings

✅ Texto limpo e normalizado
✅ Remoção de ruído (stopwords, caracteres especiais)
✅ Consistência no processamento
✅ Melhor similaridade semântica

Busca Mais Precisa

✅ Pergunta e documentos processados da mesma forma
✅ Menos falsos negativos
✅ Resultados mais relevantes

Produção Ready

✅ Biblioteca enterprise-grade (Apache Lucene)
✅ Otimizada para português (BrazilianAnalyzer)
✅ Tratamento robusto de erros
✅ Logs detalhados

🔧 Métodos Disponíveis

`preprocessForEmbedding(String text)`

Aplica todas as transformações para preparar texto para embeddings.

Usado em: Ingestão de documentos

`preprocessForQuery(String query)`

Versão otimizada para queries (mantém mais contexto).

Usado em: Perguntas dos usuários

`isValidForEmbedding(String text)`

Valida se o texto tem qualidade suficiente (mínimo 10 caracteres após processamento).

📊 Exemplo de Transformação

Texto Original:

   A Catedral da TI oferece SOLUÇÕES inovadoras!!!
   Para empresas de todos os portes...

Após Pré-processamento:

catedral ti oferec soluc inov empres port

Benefícios da transformação:

Remoção de espaços extras
Lowercase aplicado
Stopwords removidas (a, da, de, os, para)
Stemming aplicado (oferece → oferec, soluções → soluc, etc.)
Pontuação desnecessária removida

⚙️ Configuração

O serviço funciona automaticamente, sem necessidade de configuração adicional. Está integrado via CDI (Jakarta Inject) e é singleton por padrão.

✓ Validação

O sistema valida:

✅ Texto não nulo/vazio
✅ Conversão UTF-8 bem-sucedida
✅ Tamanho mínimo após processamento
✅ Tokens válidos extraídos

🚨 Tratamento de Erros

Em caso de erro no processamento:

Logs detalhados são gerados
Fallback para processamento básico (normalização de espaços)
Exceções são capturadas e tratadas
Sistema não interrompe funcionamento

📈 Performance

Processamento eficiente com Lucene
Cache de analyzer (reutilizado)
Mínimo overhead no processo de ingestão
Otimizado para grandes volumes de texto

🔮 Melhorias Futuras (Opcional)

[ ] Adicionar configuração para habilitar/desabilitar stemming
[ ] Suporte para múltiplos idiomas
[ ] Métricas de qualidade do texto
[ ] Cache de textos pré-processados

🧪 Cenário de Teste Completo

Passo a Passo para Testar o Sistema

1. Preparar Documentos

# Os documentos já estão na pasta documents/
dir C:\Users\solan\Desktop\QUARKUS-MCP\documents

2. Fazer Upload dos Documentos

# Upload do arquivo Sobre.txt
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\Sobre.txt"

# Upload do arquivo FAQ
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\PerguntasFrequentes.txt"

# Upload de Planos
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\PlanosAssinaturas.txt"

# Upload de Segurança
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\Seguranca.txt"

# Upload de Suporte
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\SuporteAtendimento.txt"

# Upload de Inovação
curl -X POST http://localhost:8080/api/documents/upload -F "file=@documents\InovacaoSustentabilidade.txt"

3. Verificar Documentos Carregados

curl http://localhost:8080/api/documents

4. Testar Chat Básico

curl -X POST http://localhost:8080/api/chat \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"O que é a empresa?\"}"

5. Testar Multi-Agentes

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como funciona a segurança da plataforma?\"}"

6. Testar MCP

curl -X POST http://localhost:8080/api/mcp/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Quais são os planos disponíveis?\"}"

7. Comparar Abordagens

curl -X POST http://localhost:8080/api/mcp/compare \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como entrar em contato com suporte?\"}"

🔍 Exemplos de Perguntas para Testar

Perguntas Sobre a Empresa

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"O que faz a empresa?\"}"

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Qual é a missão da empresa?\"}"

Perguntas Sobre Planos

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Quais planos estão disponíveis?\"}"

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Qual a diferença entre os planos?\"}"

Perguntas Sobre Segurança

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como a plataforma protege meus dados?\"}"

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Quais certificações de segurança vocês possuem?\"}"

Perguntas Sobre Suporte

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Como falar com o suporte?\"}"

curl -X POST http://localhost:8080/api/agents/ask \
  -H "Content-Type: application/json" \
  -d "{\"question\": \"Qual o horário de atendimento?\"}"

🛠️ Troubleshooting

Problema: Aplicação não inicia

Sintomas: Erro ao executar mvn quarkus:dev

Soluções:

# 1. Verificar se o PostgreSQL está rodando
docker ps

# 2. Reiniciar o banco
docker-compose down
docker-compose up -d

# 3. Limpar cache do Maven
mvn clean

# 4. Verificar a API Key do OpenAI
echo %QUARKUS_LANGCHAIN4J_OPENAI_API_KEY%

Problema: Erro de conexão com banco de dados

Sintomas: Connection refused ou Cannot connect to database

Soluções:

# Verificar se o PostgreSQL está rodando
docker-compose ps

# Ver logs do PostgreSQL
docker-compose logs postgres

# Reiniciar o container
docker-compose restart postgres

# Verificar porta 5432
netstat -an | findstr 5432

Problema: Upload de documento falha

Sintomas: Erro 500 ao fazer upload

Soluções:

Verificar se o arquivo existe no caminho especificado
Verificar tamanho do arquivo (limite padrão: 10MB)
Verificar formato do arquivo (TXT, PDF suportados)
Ver logs da aplicação para detalhes do erro

Problema: Respostas vazias ou incorretas

Sintomas: A IA retorna respostas genéricas ou vazias

Soluções:

Verificar se documentos foram carregados corretamente
Verificar se a API Key do OpenAI é válida
Aumentar o maxResults na requisição
Verificar logs para erros de embeddings

Problema: Erro de API Key

Sintomas: Unauthorized ou Invalid API Key

Soluções:

# Windows CMD
set QUARKUS_LANGCHAIN4J_OPENAI_API_KEY=sk-sua-chave-aqui

# PowerShell
$env:QUARKUS_LANGCHAIN4J_OPENAI_API_KEY="sk-sua-chave-aqui"

# Ou editar application.properties
# quarkus.langchain4j.openai.api-key=sk-sua-chave-aqui

Problema: Porta 8080 já em uso

Sintomas: Port 8080 already in use

Soluções:

# Mudar porta no application.properties
# quarkus.http.port=8081

# Ou via variável de ambiente
set QUARKUS_HTTP_PORT=8081

📊 Monitoramento e Logs

Ver Logs da Aplicação

# Durante execução em dev mode, os logs aparecem no console

# Para produção, redirecionar para arquivo
java -jar target/quarkus-app/quarkus-run.jar > app.log 2>&1

Health Check

# Verificar saúde da aplicação
curl http://localhost:8080/q/health

# Verificar métricas
curl http://localhost:8080/q/metrics

Swagger UI (se habilitado)

http://localhost:8080/q/swagger-ui

🎓 Conceitos Importantes

RAG (Retrieval-Augmented Generation)

Técnica que combina:

Retrieval: Busca semântica em documentos usando embeddings
Augmentation: Contextualiza a pergunta com documentos relevantes
Generation: LLM gera resposta baseada no contexto recuperado

Embeddings

Representação vetorial de texto que captura significado semântico.

Dimensão: 1536 (OpenAI text-embedding-ada-002)
Armazenamento: PostgreSQL + pgvector
Busca: Similaridade por cosseno

Multi-Agentes

Sistema com múltiplos agentes especializados trabalhando em colaboração:

Cada agente tem função específica
Pipeline orquestrado para melhor resultado
Transparência nas etapas de processamento

📚 Referências e Documentação

Tecnologias Utilizadas

Quarkus: https://quarkus.io/
LangChain4j: https://docs.langchain4j.dev/
PostgreSQL: https://www.postgresql.org/
pgvector: https://github.com/pgvector/pgvector
OpenAI: https://platform.openai.com/docs

Documentação Adicional

Quarkus LangChain4j: https://docs.quarkiverse.io/quarkus-langchain4j/
gRPC: https://grpc.io/
Protocol Buffers: https://protobuf.dev/

🎉 Conclusão

Você agora tem um sistema RAG completo com multi-agentes funcionando!

Próximos Passos

✅ Carregar seus próprios documentos
✅ Testar diferentes tipos de perguntas
✅ Comparar as abordagens LangChain4j vs MCP
✅ Explorar métricas de performance
✅ Customizar os agentes conforme necessidade

Suporte

Para dúvidas ou problemas:

Verificar seção de Troubleshooting
Consultar logs da aplicação
Revisar configurações do application.properties

Versão do Guia: 1.0
Data: Outubro 2025
Projeto: QUARKUS-MCP RAG Multi-Agentes