Integrar Agentes (Exercicio Final)

// Definicao de um agente
interface AgentDefinition {
  id: string              // Ex: 'research-agent'
  name: string            // Ex: 'Agente de Pesquisa'
  role: string            // 1 frase descrevendo o que ele faz
  model: string           // Ex: 'claude-sonnet-4-20250514', 'gpt-4o', 'qwen2.5:14b'

  systemPrompt: string    // Prompt que define personalidade e restricoes

  tools: ToolDefinition[] // Quais tools esse agente pode usar
  mcpServers: string[]    // Quais MCP servers tem acesso

  memory: {
    shortTerm: boolean    // Mantem historico da conversa atual?
    longTerm: boolean     // Persiste preferencias entre sessoes?
    knowledge: boolean    // Acessa knowledge base?
  }

  communication: {
    canReceiveFrom: string[]  // Quais agentes podem delegar pra ele
    canDelegateTo: string[]   // Pra quais agentes ele pode delegar
    handoffFormat: 'structured' | 'summary' | 'full'
  }

  constraints: {
    maxIterations: number   // Limite do loop ReAct
    timeout: number         // Timeout em ms
    requiresApproval: boolean // Precisa de confirmacao humana?
  }
}

function routeMessage(message: string): string {
  const lower = message.toLowerCase()

  // Comandos explicitos (maior prioridade)
  if (lower.startsWith('/research')) return 'research-agent'
  if (lower.startsWith('/write'))    return 'writer-agent'
  if (lower.startsWith('/review'))   return 'review-agent'

  // Keywords
  const researchKeywords = ['pesquise', 'busque', 'encontre', 'dados sobre']
  const writeKeywords = ['escreva', 'crie', 'gere', 'redija', 'artigo']
  const reviewKeywords = ['revise', 'avalie', 'corrija', 'feedback']

  if (researchKeywords.some(k => lower.includes(k))) return 'research-agent'
  if (writeKeywords.some(k => lower.includes(k)))    return 'writer-agent'
  if (reviewKeywords.some(k => lower.includes(k)))   return 'review-agent'

  // Fallback: agente padrao
  return 'writer-agent'
}

async function routeWithLLM(message: string): Promise<string> {
  const classification = await llm.chat({
    model: 'qwen2.5:14b',  // Modelo local, rapido, gratis
    messages: [{
      role: 'system',
      content: `Classifique a mensagem do usuario em UMA das categorias:
- research: usuario quer encontrar informacoes, dados, analises
- write: usuario quer criar conteudo, texto, documentacao
- review: usuario quer avaliar, corrigir ou melhorar algo existente

Responda APENAS com o nome da categoria, nada mais.`
    }, {
      role: 'user',
      content: message
    }],
    temperature: 0  // Deterministico
  })

  const agentMap: Record<string, string> = {
    'research': 'research-agent',
    'write': 'writer-agent',
    'review': 'review-agent'
  }

  const category = classification.trim().toLowerCase()
  return agentMap[category] || 'writer-agent'  // Fallback
}

async function routeHybrid(message: string): Promise<string> {
  // 1. Comandos explicitos (zero custo, alta confianca)
  if (message.startsWith('/')) {
    const command = message.split(' ')[0].toLowerCase()
    const commandMap: Record<string, string> = {
      '/research': 'research-agent',
      '/write': 'writer-agent',
      '/review': 'review-agent'
    }
    if (commandMap[command]) return commandMap[command]
  }

  // 2. Keywords de alta confianca
  const rulesResult = routeByKeywords(message)
  if (rulesResult.confidence > 0.8) return rulesResult.agent

  // 3. LLM classifier para casos ambiguos
  return routeWithLLM(message)
}

// Registro de tools por agente
const agents = {
  'research-agent': {
    model: 'gpt-4o-mini',
    systemPrompt: researchPrompt,
    tools: [
      webSearchTool,      // Busca na web
      scrapeUrlTool,      // Extrai conteudo de URL
      analyzeDataTool     // Analisa dados coletados
    ]
  },
  'writer-agent': {
    model: 'claude-sonnet-4-20250514',
    systemPrompt: writerPrompt,
    tools: [
      writeFileTool,      // Escreve arquivo no filesystem
      formatMarkdownTool, // Formata em markdown
      readFileTool        // Le arquivo existente (via MCP)
    ]
  },
  'review-agent': {
    model: 'gpt-4o',
    systemPrompt: reviewPrompt,
    tools: [
      factCheckTool,      // Verifica fatos online
      scoreQualityTool,   // Da nota de qualidade
      suggestEditsTool    // Sugere edicoes especificas
    ]
  }
}

// Executar agente com suas tools
async function runAgent(agentId: string, input: string) {
  const agent = agents[agentId]
  const response = await llm.chat({
    model: agent.model,
    messages: [
      { role: 'system', content: agent.systemPrompt },
      { role: 'user', content: input }
    ],
    tools: agent.tools.map(t => t.schema)  // JSON Schemas
  })

  // Se o LLM pediu tool call, executar
  if (response.tool_calls) {
    for (const call of response.tool_calls) {
      const tool = agent.tools.find(t => t.name === call.function.name)
      const result = await tool.execute(call.function.arguments)
      // Retornar resultado ao LLM para continuar
    }
  }
}

import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StdioClientTransport } from
  '@modelcontextprotocol/sdk/client/stdio.js'

// Conectar ao MCP Server de filesystem
const transport = new StdioClientTransport({
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-filesystem',
         '/home/user/projetos']
})

const mcpClient = new Client({ name: 'my-saas', version: '1.0' })
await mcpClient.connect(transport)

// Listar tools disponiveis
const { tools } = await mcpClient.listTools()
console.log('MCP tools:', tools.map(t => t.name))
// ['read_file', 'write_file', 'list_directory', ...]

// Usar uma tool do MCP
const result = await mcpClient.callTool({
  name: 'read_file',
  arguments: { path: '/home/user/projetos/meu-saas/README.md' }
})

// Combinar tools locais + MCP tools no agente
const allTools = [...localTools, ...mcpTools]

// test-tools.ts - Teste individual de cada tool
async function testTools() {
  console.log('=== Testando web_search ===')
  const searchResult = await webSearchTool.execute({
    query: 'MCP Model Context Protocol'
  })
  console.log('Resultado:', searchResult.slice(0, 200))
  assert(searchResult.length > 0, 'web_search deve retornar resultados')

  console.log('=== Testando write_file (MCP) ===')
  const writeResult = await mcpClient.callTool({
    name: 'write_file',
    arguments: {
      path: '/tmp/test-output.md',
      content: '# Teste\nConteudo de teste.'
    }
  })
  assert(writeResult.content, 'write_file deve confirmar escrita')

  console.log('=== Testando score_quality ===')
  const scoreResult = await scoreQualityTool.execute({
    text: 'Este e um artigo de teste sobre inteligencia artificial.'
  })
  assert(scoreResult.score >= 0 && scoreResult.score <= 10)

  console.log('Todos os testes passaram!')
}

testTools().catch(console.error)

async function processMessage(userId: string, message: string) {
  const startTime = Date.now()
  const memory = new MemoryManager(db, userId)

  // 1. Carregar contexto do usuario
  const context = await memory.loadForPrompt()

  // 2. Classificar e rotear
  const agentId = await routeHybrid(message)
  console.log(`[ROUTE] "${message}" -> ${agentId}`)

  // 3. Executar agente com tools + contexto
  const agent = agents[agentId]
  const response = await runAgentLoop(agent, message, context)
  console.log(`[EXECUTE] ${agentId} completed in ${Date.now()-startTime}ms`)

  // 4. Atualizar memoria
  await memory.saveMessages([
    { role: 'user', content: message },
    { role: 'assistant', content: response.text }
  ])

  // 5. Extrair fatos para long-term memory
  const facts = await memory.extractFacts([
    { role: 'user', content: message },
    { role: 'assistant', content: response.text }
  ])
  if (facts.length > 0) {
    for (const fact of facts) {
      await memory.addKnowledge(fact.content, fact.type)
    }
  }

  // 6. Compactar se necessario
  await memory.compactIfNeeded()

  // 7. Retornar resposta
  console.log(`[DONE] Total: ${Date.now()-startTime}ms, ` +
    `tokens: ${response.tokensUsed}`)
  return response.text
}

meu-saas-agentes/
  src/
    agents/
      research.ts        // Agente de pesquisa + tools
      writer.ts          // Agente de escrita + tools
      review.ts          // Agente de revisao + tools (opcional)
    skills/
      web-search.ts      // Tool: busca web
      file-ops.ts        // Tool: operacoes de arquivo
      data-analysis.ts   // Tool: analise de dados
    memory/
      manager.ts         // MemoryManager unificado
      conversation.ts    // Historico de conversas
      preferences.ts     // Preferencias do usuario
      knowledge.ts       // Knowledge base
    router.ts            // Classificacao e dispatch
    orchestrator.ts      // Coordenacao entre agentes
    main.ts              // Entry point
  mcp-config.json        // Config dos MCP Servers
  schema.sql             // DDL das tabelas
  test-scenarios.ts      // Testes end-to-end
  .env                   // API keys
  README.md              // Como rodar o projeto