O maior gargalo na construção de agentes jurídicos de IA não é o modelo de linguagem — é o acesso a dados reais. Um LLM sem fonte de dados processuais atualizada apenas alucina precedentes, inventa andamentos e gera respostas que parecem precisas mas não têm nenhuma aderência à realidade do processo.

O Model Context Protocol (MCP) resolve isso de forma elegante: em vez de o desenvolvedor construir uma integração customizada entre o agente e cada fonte de dados, o MCP padroniza como modelos de linguagem se conectam a ferramentas e serviços externos. A Judit é a primeira infraestrutura de dados judiciais do Brasil com servidor MCP nativo.

Este artigo explica como conectar seu agente à Judit via MCP — do zero até em produção.

Agentes jurídicos de IA via MCP: acesso a dados processuais reais sem integração customizada

O que é MCP e por que é essencial para agentes jurídicos de IA

MCP (Model Context Protocol) é um protocolo aberto desenvolvido pela Anthropic que define como modelos de linguagem se comunicam com ferramentas externas. Em vez de cada plataforma de IA inventar seu próprio formato de integração, o MCP cria um contrato padrão: qualquer servidor MCP pode ser conectado a qualquer cliente MCP compatível.

Na prática, isso significa que um agente pode consultar um processo no TJSP, buscar o histórico de um CPF, verificar mandados de prisão ou monitorar uma carteira inteira — sem que o desenvolvedor precise implementar a lógica de chamada HTTP, parsing de resposta e tratamento de erros para cada uma dessas operações. O servidor MCP da Judit expõe todas essas capacidades como ferramentas prontas para uso pelo modelo.

Para dados jurídicos, essa padronização é especialmente importante. O judiciário brasileiro tem mais de 90 tribunais com estruturas distintas. A Judit já resolveu o problema de coleta, normalização e acesso — o MCP é a camada que torna esses dados nativamente consumíveis por agentes de IA.

O servidor MCP da Judit

O servidor MCP da Judit está disponível em:

https://docs.judit.io/mcp

Transporte: HTTP (compatível com todos os clientes MCP modernos).

O servidor expõe capacidades de consulta à base de conhecimento da Judit e acesso à documentação técnica, permitindo que agentes entendam como usar a API e executem consultas guiadas. Combinado com a REST API da Judit via ferramentas customizadas, isso viabiliza agentes jurídicos completos — desde a interpretação da necessidade até a entrega do dado processual.

Configurando em ambientes prontos

Claude Desktop

Abra o arquivo de configuração do Claude Desktop:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Adicione o servidor MCP da Judit:

{
  "mcpServers": {
    "judit": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://docs.judit.io/mcp"
      ]
    }
  }
}

Reinicie o Claude Desktop. A partir daí, o Claude terá acesso às ferramentas da Judit e poderá responder perguntas sobre a API, gerar código de integração e orientar implementações com base na documentação técnica real.

Cursor

No Cursor, acesse Settings → MCP e adicione:

{
  "mcpServers": {
    "judit": {
      "url": "https://docs.judit.io/mcp",
      "transport": "http"
    }
  }
}

Com isso, ao escrever código de integração com a Judit, o Cursor pode consultar a documentação real para autocomplete de parâmetros, validação de schemas e sugestões de implementação.

Outros clientes MCP

Qualquer cliente compatível com MCP via HTTP pode se conectar usando a URL https://docs.judit.io/mcp. Isso inclui Zed, Windsurf, Continue.dev e frameworks de agentes como LangChain, LlamaIndex e AutoGen.

Construindo um agente jurídico customizado

Para agentes que precisam tanto de orientação via documentação quanto de acesso a dados processuais em tempo real, a arquitetura combina o servidor MCP com chamadas diretas à REST API da Judit.

Instalando o SDK MCP

# Node.js
npm install @modelcontextprotocol/sdk

# Python
pip install mcp

Agente com acesso à documentação e à API

import anthropic
import httpx
import os

JUDIT_API_KEY = os.environ['JUDIT_API_KEY']

client = anthropic.Anthropic()

def consultar_processo(numero_cnj: str) -> dict:
    """Chama a Judit REST API para buscar um processo."""
    res = httpx.post(
        'https://requests.prod.judit.io/requests/',
        headers={
            'api-key': JUDIT_API_KEY,
            'Content-Type': 'application/json'
        },
        json={
            'search': {
                'search_type': 'lawsuit_cnj',
                'search_key': numero_cnj,
                'cache_ttl_in_days': 1
            },
            'judit_ia': ['summary']
        }
    )
    return res.json()

def buscar_perfil_litigioso(documento: str, tipo: str = 'cnpj') -> dict:
    """Retorna o perfil litigioso agrupado de um CPF ou CNPJ."""
    res = httpx.post(
        'https://lawsuits.production.judit.io/requests/create/grouped',
        headers={
            'api-key': JUDIT_API_KEY,
            'Content-Type': 'application/json'
        },
        json={'search': {'search_type': tipo, 'search_key': documento}}
    )
    return res.json()

# Ferramentas que o agente pode usar
tools = [
    {
        "name": "consultar_processo",
        "description": "Consulta um processo judicial pelo número CNJ. Retorna dados completos incluindo partes, andamentos e resumo da Judit IA.",
        "input_schema": {
            "type": "object",
            "properties": {
                "numero_cnj": {
                    "type": "string",
                    "description": "Número do processo no formato CNJ: 9999999-99.9999.9.99.9999"
                }
            },
            "required": ["numero_cnj"]
        }
    },
    {
        "name": "buscar_perfil_litigioso",
        "description": "Retorna o perfil litigioso de um CPF ou CNPJ: total de processos, distribuição por área do direito, tribunais e fase processual.",
        "input_schema": {
            "type": "object",
            "properties": {
                "documento": {
                    "type": "string",
                    "description": "CPF ou CNPJ da entidade"
                },
                "tipo": {
                    "type": "string",
                    "enum": ["cpf", "cnpj"],
                    "description": "Tipo do documento"
                }
            },
            "required": ["documento", "tipo"]
        }
    }
]

def executar_ferramenta(nome: str, parametros: dict) -> dict:
    if nome == "consultar_processo":
        return consultar_processo(parametros['numero_cnj'])
    if nome == "buscar_perfil_litigioso":
        return buscar_perfil_litigioso(parametros['documento'], parametros.get('tipo', 'cnpj'))
    return {"erro": f"Ferramenta '{nome}' não encontrada"}

def agente_juridico(pergunta: str) -> str:
    """Agente jurídico com acesso a dados processuais reais."""
    mensagens = [{"role": "user", "content": pergunta}]

    while True:
        resposta = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            system=(
                "Você é um assistente jurídico especializado em direito brasileiro. "
                "Você tem acesso a dados processuais em tempo real via ferramentas. "
                "Use as ferramentas disponíveis para responder com base em dados reais. "
                "Nunca invente informações sobre processos — sempre consulte a API."
            ),
            tools=tools,
            messages=mensagens
        )

        # Se o modelo quer usar uma ferramenta
        if resposta.stop_reason == "tool_use":
            # Adiciona a resposta do assistente ao histórico
            mensagens.append({"role": "assistant", "content": resposta.content})

            # Executa as ferramentas solicitadas
            resultados = []
            for bloco in resposta.content:
                if bloco.type == "tool_use":
                    resultado = executar_ferramenta(bloco.name, bloco.input)
                    resultados.append({
                        "type": "tool_result",
                        "tool_use_id": bloco.id,
                        "content": str(resultado)
                    })

            mensagens.append({"role": "user", "content": resultados})
            continue

        # Resposta final em texto
        return next(b.text for b in resposta.content if hasattr(b, 'text'))


# Exemplos de uso
if __name__ == "__main__":
    resposta = agente_juridico(
        "Qual é a situação atual do processo 0001234-12.2024.8.19.0001? "
        "Quais são as partes e o último andamento?"
    )
    print(resposta)

    perfil = agente_juridico(
        "Faça uma análise de risco jurídico do CNPJ 00.000.000/0001-00. "
        "Quantos processos tem? Em quais áreas? Quantos está como réu?"
    )
    print(perfil)

Versão em JavaScript

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();
const JUDIT_API_KEY = process.env.JUDIT_API_KEY;

const tools = [
  {
    name: 'consultar_processo',
    description: 'Consulta um processo judicial pelo número CNJ.',
    input_schema: {
      type: 'object',
      properties: {
        numero_cnj: { type: 'string', description: 'Número CNJ do processo' }
      },
      required: ['numero_cnj']
    }
  },
  {
    name: 'buscar_perfil_litigioso',
    description: 'Retorna perfil litigioso de um CPF ou CNPJ.',
    input_schema: {
      type: 'object',
      properties: {
        documento: { type: 'string' },
        tipo: { type: 'string', enum: ['cpf', 'cnpj'] }
      },
      required: ['documento', 'tipo']
    }
  }
];

async function executarFerramenta(nome, params) {
  const headers = { 'api-key': JUDIT_API_KEY, 'Content-Type': 'application/json' };

  if (nome === 'consultar_processo') {
    const res = await fetch('https://requests.prod.judit.io/requests/', {
      method: 'POST',
      headers,
      body: JSON.stringify({
        search: { search_type: 'lawsuit_cnj', search_key: params.numero_cnj },
        judit_ia: ['summary']
      })
    });
    return res.json();
  }

  if (nome === 'buscar_perfil_litigioso') {
    const res = await fetch('https://lawsuits.production.judit.io/requests/create/grouped', {
      method: 'POST',
      headers,
      body: JSON.stringify({
        search: { search_type: params.tipo, search_key: params.documento }
      })
    });
    return res.json();
  }
}

async function agenteJuridico(pergunta) {
  const mensagens = [{ role: 'user', content: pergunta }];

  while (true) {
    const resposta = await client.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 4096,
      system: 'Você é um assistente jurídico com acesso a dados processuais reais. Use as ferramentas para responder com base em dados atualizados. Nunca invente informações sobre processos.',
      tools,
      messages: mensagens
    });

    if (resposta.stop_reason === 'tool_use') {
      mensagens.push({ role: 'assistant', content: resposta.content });

      const resultados = await Promise.all(
        resposta.content
          .filter(b => b.type === 'tool_use')
          .map(async b => ({
            type: 'tool_result',
            tool_use_id: b.id,
            content: JSON.stringify(await executarFerramenta(b.name, b.input))
          }))
      );

      mensagens.push({ role: 'user', content: resultados });
      continue;
    }

    return resposta.content.find(b => b.type === 'text')?.text;
  }
}

Casos de uso práticos de agentes jurídicos de IA

Assistente jurídico para escritórios

Um advogado pergunta em linguagem natural: “Me dá um resumo do processo 0001234-12.2024.8.19.0001, as últimas três movimentações e se há alguma audiência marcada.”

O agente consulta a Judit API, recebe os dados estruturados com o resumo da Judit IA, e entrega uma resposta formatada — sem o advogado precisar abrir o portal do tribunal.

Análise de risco em crédito

O analista pergunta: “Antes de aprovar o crédito para o CNPJ 00.000.000/0001-00, me diz quantos processos trabalhistas ativos tem e se há recuperação judicial.”

O agente chama buscar_perfil_litigioso, interpreta os campos areas, phases e special_status, e devolve um parecer em linguagem natural com os dados reais.

Due diligence automatizada

Em um fluxo de M&A, o agente recebe uma lista de CNPJs e gera automaticamente um relatório de passivo judicial para cada empresa — combinando consulta agrupada para o resumo e consulta assíncrona completa para os processos de maior valor.

Compliance contínuo

Um agente monitora uma carteira de fornecedores e, a cada movimentação relevante entregue via webhook, gera automaticamente um relatório de impacto em linguagem natural para o time de compliance.

Boas práticas para agentes jurídicos

Nunca deixe o modelo inventar dados processuais. O system prompt deve ser explícito: o agente só pode afirmar fatos sobre processos se consultou a API. Dados jurídicos têm implicações legais — alucinação aqui não é aceitável.

Use judit_ia: ["summary"] para resumos, não o LLM. O modelo proprietário da Judit já foi treinado para resumir processos jurídicos. Delegar o resumo para a Judit IA e usar o LLM apenas para interpretar e comunicar o resultado é mais preciso e mais barato.

Implemente cache no agente. Se o mesmo CPF/CNPJ for consultado várias vezes na mesma sessão, o agente deve reutilizar o resultado da primeira consulta. Use cache_ttl_in_days na chamada à API e mantenha um dicionário de resultados na memória do agente.

Trate request_id como dado de auditoria. Em ambientes regulados, cada consulta jurídica feita pelo agente deve ser registrada com o request_id retornado pela Judit. Isso garante rastreabilidade completa de quais dados embasaram cada decisão.

Limite o escopo das ferramentas pelo perfil do usuário. Um agente de atendimento ao cliente não precisa de acesso a consultas criminais. Instancie o agente apenas com as ferramentas necessárias para o caso de uso específico.

Próximos passos

Para começar:

1. Conecte o servidor MCP da Judit no seu cliente de IA preferido: https://docs.judit.io/mcp

Publicado em: abril de 2026 — Atualizado a cada trimestre