Tutorial Codex CLI MCP: criando um agente de dashboard de portfólio

Você provavelmente já percebeu que agentes de codificação com IA são incrivelmente úteis para escrever funções complexas ou depurar erros chatos. Mas eles costumam bater em um limite: deixam de ser úteis quando você precisa de informações que não estão dentro dos arquivos do seu projeto.

Agora, imagine se seu agente pudesse buscar dados ao vivo fora desse ambiente, consultar documentação atualizada ou usar diferentes ferramentas por você. É aí que esses agentes ficam realmente poderosos.

Neste tutorial, vou mostrar exatamente como fazer isso usando o Codex CLI e o Model Context Protocol, ou MCP. Vamos ver os fundamentos de como o Codex CLI e o MCP trabalham juntos, construir do zero um projeto de dashboard financeiro com dados de ações em tempo real, cobrir padrões multiagente e discutir boas práticas de segurança.

Para aproveitar ao máximo, recomendo que você acompanhe na prática. Crie um novo projeto Next.js, garanta que o Codex CLI esteja instalado e funcionando, e gere uma chave de API gratuita na Alpha Vantage para começarmos a construir.

Se você é novo em IA agentiva, recomendo fortemente se inscrever na nossa trilha de habilidades AI Agent Fundamentals.

Fundamentos de Codex CLI MCP

Antes de começar a codar, precisamos entender as ferramentas. Vamos destrinchar o que é o MCP e como o Codex CLI o utiliza.

O que é MCP?

MCP significa Model Context Protocol. É um padrão aberto introduzido pela Anthropic para padronizar como sistemas de IA se conectam a ferramentas e fontes de dados externas. Tecnicamente, ele opera via JSON-RPC 2.0 sobre STDIO (entrada/saída padrão) ou HTTP.

Fonte: truefoundry

Isso é importante porque resolve um grande problema — o “pesadelo das integrações”. Antes, para conectar um LLM a um banco de dados ou ferramenta específicos, você precisava criar um conector sob medida para cada par. Era bagunçado, difícil de manter e pouco escalável.

Com o MCP, temos um protocolo único e unificado para todas as conexões de ferramentas de LLM. Ele simplifica o cenário ao substituir integrações customizadas por uma interface padrão.

Se quiser entender o que acontece “por baixo do capô”, este passo a passo para construir um servidor e cliente MCP do zero é um bom complemento.

O que é o Codex CLI?

Agora, vamos falar do Codex CLI. É o agente de codificação leve da OpenAI, baseado em terminal. Assim como outras ferramentas com IA, como o Claude Code ou o Cursor, ele é projetado para entender todo o contexto do seu projeto, e não só o arquivo que você abriu.

Ele reúne tudo em um só lugar, combinando indexação eficiente do código, o histórico da conversa e a execução de comandos em uma interface de texto (TUI). Quase todo o seu comportamento pode ser controlado e personalizado editando o arquivo config.toml, o que facilita a gestão.

Como o Codex implementa o MCP

Em termos de implementação, o Codex suporta servidores STDIO e servidores HTTP “streamable”:

• Servidores STDIO rodam como processos locais. Pense neles como comandos e argumentos específicos executados diretamente na sua máquina.
• Servidores HTTP streamable conectam remotamente via URL e, opcionalmente, suportam token bearer ou autenticação por OAuth.

Um recurso bem conveniente é que o Codex CLI e a extensão de IDE compartilham o mesmo arquivo config.toml. Assim, você tem as mesmas ferramentas MCP no terminal e no editor; não precisa configurar duas vezes, economizando tempo.

O Codex também lida bem com autenticação, suportando OAuth via o comando codex mcp login <server-name>. E ainda dá controle fino sobre o que o agente pode fazer, permitindo filtrar ferramentas específicas com as chaves enabled_tools ou disabled_tools na configuração.

Configuração do Codex CLI com MCP

Teoria vista, hora de colocar a mão na massa. Nesta seção, vamos ver como configurar seus servidores MCP para ficarem prontos para uso.

Pré-requisitos

Antes de integrar o Codex ao MCP e ao Agents SDK, garanta que você tenha:

• O Codex CLI instalado na máquina. Para instalar globalmente, abra o terminal e rode npm install -g @openai/codex. Verifique com codex --version.

• O Codex autenticado na máquina. Rode codex login (ou codex login --device-auth em ambientes headless) uma vez e verifique se o Codex funciona normalmente no terminal.

• Para o fluxo multiagente, você também precisa de uma chave da OpenAI. Gere na console da OpenAI e defina no shell com export OPENAI_API_KEY="sk-...".

• Variáveis de ambiente para ferramentas externas definidas. Por exemplo, a Alpha Vantage lê sua chave de dados de mercado de ALPHA_VANTAGE_KEY, que você também deve exportar antes de rodar os exemplos.

Para obter uma chave de API da AlphaVantage:

1. Acesse a página de suporte da AlphaVantage.
2. Preencha o formulário rápido (organização, cargo e e-mail).
3. Sua chave será exibida na hora. Copie e guarde com segurança.

O plano gratuito permite até 25 requisições por dia. Para uso mais intenso, a Alpha Vantage oferece planos premium.

Adicionando servidores MCP via CLI

Em seguida, vamos adicionar um novo servidor usando a linha de comando com codex mcp add. Assim, você não precisa editar arquivos de configuração manualmente — o Codex faz a maior parte do trabalho.

Por exemplo, para ajudar a consultar documentação, você pode usar o servidor MCP Context7. Para instalar, rode no terminal:

codex mcp add context7 -- npx -y @upstash/context7-mcp

Adicionando servidores MCP via config.toml

Embora os comandos de CLI sejam ótimos para começar rápido, às vezes você precisa de mais controle — ou prefere ver exatamente o que está acontecendo. Nesse caso, edite o arquivo de configuração diretamente.

É importante saber que existem dois lugares para essa configuração, com escopos diferentes:

• Arquivo global em ~/.codex/config.toml, aplicável a todos os projetos

• Arquivo por projeto em .codex/config.toml dentro da pasta do projeto. Em geral, configurações do projeto substituem as globais quando há conflito.

Nem todos os servidores MCP vêm com comando de instalação via CLI. Nesses casos, configure-os direto em ~/.codex/config.toml, especificando o comando e os argumentos necessários para iniciar o processo do servidor. Assim, você controla totalmente como ele é iniciado, seja localmente via STDIO ou remotamente via HTTP.

O servidor MCP da AlphaVantage é um desses. Abra o config.toml e adicione o bloco abaixo:

[mcp_servers.alphavantage]
command = "uvx"
args = ["av-mcp", "<your-key>”]

Aviso: gravar a chave de API diretamente no config.toml não é recomendado em projetos reais. Evite isso em qualquer projeto versionado (por exemplo, no GitHub), compartilhado com outros desenvolvedores ou implantado em servidor, pois qualquer pessoa com acesso ao arquivo poderá ler e usar sua chave indevidamente. Para este tutorial, tudo bem, já que o config.toml fica no seu diretório pessoal (~/.codex/) e é exclusivo da sua máquina.

Uma linha útil de adicionar é startup_timeout_sec=30 para substituir o timeout padrão de 10 segundos, dando tempo suficiente para a conexão se estabelecer.

Gerenciando servidores MCP

Depois de configurar alguns servidores, você vai querer gerenciá-los. O Codex oferece uma série de comandos para manter tudo organizado.

Para ver o que está instalado, rode codex mcp list. Para checar os detalhes de um servidor específico, como o Alpha Vantage que acabamos de adicionar, rode codex mcp get alphavantage. E, claro, se não precisar mais de um servidor — por exemplo, o Context7 — remova-o com codex mcp remove context7.

Por fim, durante uma sessão ativa do Codex, você pode verificar se tudo está rodando corretamente. Digite /mcp direto na interface de chat e ele mostrará o status das ferramentas conectadas. Deve aparecer alphavantage e context7, ambos com Status: enabled.

Construindo um dashboard de risco de portfólio com Codex e MCP

Teoria ajuda, mas o melhor jeito de aprender é construindo algo real. Nesta seção, vamos montar do zero um dashboard de risco de portfólio funcional, usando Codex e MCP para buscar dados de mercado reais e calcular métricas de risco.

Para exibir o dashboard, o projeto usa TypeScript, linguagem baseada em JavaScript. Para um reforço em diferentes níveis, recomendo nosso guia de perguntas de entrevista de TypeScript.

Preparando o projeto

Siga os passos abaixo para configurar o projeto:

1. Inicialize o projeto: rode o comando padrão do Next.js no terminal: npx create-next-app@latest portfolio-dashboard --typescript

2. Aceite os prompts padrão para manter a configuração padrão

3. Navegue até a pasta do novo projeto: cd portfolio-dashboard

4. Prepare a estrutura de componentes criando um subdiretório para a UI: mkdir components

5. Crie o card do portfólio como um arquivo .tsx em components: components/PortfolioCard.tsx

O componente define um PortfolioCard que renderiza um card estilizado com posições fictícias (AAPL e TSLA), mostrando símbolo, número de ações e preço atual. Usa classes do Tailwind CSS para layout e estilo, com card branco e preço em verde-esmeralda. Deve ficar assim:

// components/PortfolioCard.tsx
import React from 'react';

type Position = {
  symbol: string;
  shares: number;
  price: number;
};

const mockPositions: Position[] = [
  { symbol: 'AAPL', shares: 10, price: 150.00 },
  { symbol: 'TSLA', shares: 5, price: 900.00 },
];

export const PortfolioCard = () => {
  return (
    // Added text-slate-900 to ensure visibility on the white background
    <div className="p-6 border border-slate-200 rounded-xl shadow-sm bg-white text-slate-900">
      <h2 className="text-xl font-bold mb-4">My Portfolio</h2>
      <ul className="divide-y divide-slate-100">
        {mockPositions.map((pos) => (
          <li key={pos.symbol} className="flex justify-between py-3">
            <div className="flex flex-col">
              <span className="font-bold text-slate-800">{pos.symbol}</span>
              <span className="text-sm text-slate-500">{pos.shares} shares</span>
            </div>
            <span className="font-mono font-semibold text-emerald-600">
              ${pos.price.toFixed(2)}
            </span>
          </li>
        ))}
      </ul>
    </div>
  );
};

Depois de salvar o arquivo, importe e use <PortfolioCard/> no arquivo principal app/page.tsx para ver no navegador:

// app/page.tsx
import { PortfolioCard } from "../components/PortfolioCard";

export default function Page() {
  return (
    <main className="min-h-screen flex items-center justify-center bg-slate-50">
      <PortfolioCard />
    </main>
  );
}

Ao rodar npm run dev, você deverá ver algo como:

Antes de começar a programar com IA, garanta que os agentes estejam ativos. Deixe o terminal rodando com npm run dev. Em uma nova janela de terminal:

1. Rode os comandos de configuração do MCP citados acima, se ainda não fez

2. Exporte sua chave de API com export ALPHA_VANTAGE_KEY=”<your-key>”

3. Na mesma janela, inicie o agente Codex com codex

Implementando o recurso de índice de Sharpe

A primeira métrica será o índice de Sharpe, essencial para avaliar retorno ajustado ao risco. Normalmente é chato procurar a fórmula e a biblioteca certa. Vamos deixar o Codex cuidar disso.

Na sessão do Codex no terminal, digite o prompt:

"Add Sharpe ratio calculation for each position to PortfolioCard.tsx. Use Context7 to check the function signature if needed."

Você verá o Codex entrar em ação. Primeiro, ele pode usar o Context7 para consultar a documentação da biblioteca de análise técnica (ta-lib ou equivalente em JavaScript) e garantir os inputs corretos. Depois, ele vai modificar automaticamente seu PortfolioCard.tsx.

É provável que ele expanda mockPositions e adicione uma função auxiliar para calcular o índice, algo assim:

function calculateSharpe(prices: number[]) {
  // Codex implements the logic here using standard deviation and mean returns
  // resulting in a return value like 1.23
}

E vai atualizar o JSX para renderizar a nova métrica:

<PortfolioCard sharpe={calculateSharpe(prices)}/>

Ao checar o navegador, você verá o índice de Sharpe (ex.: 1,23) ao lado das posições, como:

Adicionando alertas de volatilidade

Agora vamos tornar o dashboard reativo usando dados reais da AlphaVantage. Queremos alertas quando uma ação ficar volátil demais. Vamos definir “alta volatilidade” como volatilidade de 7 dias acima de 3%.

No terminal do Codex, digite:

"Flag positions where 7-day volatility > 2% using Alpha Vantage data. Fetch the price history for the symbols in my list."

Aqui o MCP brilha. O Codex percebe que precisa de dados externos. Ele chamará alphavantage.get_price_history("AAPL") e alphavantage.get_price_history("TSLA") para obter os pontos reais.

Depois de recuperar os dados, ele escreverá a lógica para calcular o desvio padrão dos preços. Por fim, atualizará o estilo do componente para sinalizar o risco visualmente.

Você verá o PortfolioCard com estilização condicional. A lógica pode ser assim:

<li className={volatility > 2 ? "text-red-500 font-bold" : "text-green-500"}>
  {pos.symbol}: {volatility}%
</li>

Ao olhar o app rodando, pode ver AAPL em verde (segura) e TSLA em vermelho (volátil), tudo com base em dados ao vivo puxados pelo agente.

O resultado final deve ficar parecido com isto:

Sua UI final pode ser um pouco diferente da imagem, dependendo de como o Codex estruturou. Claro, você também pode ser mais específico no prompt e dizer como quer o resultado.

Se você quer projetar sistemas maiores e aprender sobre handoffs, limites de ferramentas e avaliação, recomendo nosso curso Building Scalable Agentic Systems.

Rodando o Codex como um servidor MCP

Até agora, usamos o Codex como a interface principal que chama outras ferramentas. Mas aqui fica interessante: o Codex também pode atuar como um servidor MCP.

Isso significa expor os poderosos recursos do Codex para edição de arquivos e execução de comandos a outros clientes MCP — permitindo que outros agentes de IA usem o Codex como ferramenta em seus próprios fluxos. A maior vantagem é possibilitar execução em paralelo.

Você pode ter um agente usando o Codex para construir o frontend, enquanto outro usa outra instância do Codex para escrever a API backend. Como rodam em processos separados, podem trabalhar simultaneamente, potencialmente cortando o tempo de desenvolvimento pela metade.

Iniciando o modo servidor do Codex

Para colocar o Codex nesse modo, use o comando: codex mcp-server.

Ao rodar, o Codex deixa de ser um chat e passa a ouvir instruções de outro programa. Ele expõe suas capacidades via STDIO.

Antes de integrar em um sistema complexo, vale testar. A equipe do Model Context Protocol fornece uma ferramenta de inspeção. Rode no terminal para abrir uma interface web conectando à sua instância local do Codex:

npx @modelcontextprotocol/inspector codex mcp-server

Isso abrirá o navegador onde você pode enviar comandos manualmente ao Codex e ver como ele responde, o que ajuda no debug. A UI é assim:

Integração com OpenAI Agents SDK

Se você programa em Python, pode orquestrar o Codex dentro de um script usando o OpenAI Agents SDK. Isso permite construir um programa em Python que “contrata” o Codex para tarefas de código específicas.

Veja um exemplo rápido. Você usa MCPServerStdio para iniciar o processo do Codex:

No seu ambiente virtual Python, instale o pacote openai-agents:

pip install openai-agents

Para configurar o processo do Codex, crie um orchestrator.py com o código a seguir:

from agents import Agent
from agents.mcp import MCPServerStdio

# initialize connection
codex_server = MCPServerStdio(
    name="Codex CLI",
    params={
        "command": "npx",
        "args": ["-y", "codex", "mcp-server"]
    },
    client_session_timeout_seconds=360000,
)
# create codex agent
agent = Agent(
    name="Lead Developer",
    mcp_servers=[codex_server]
)

Nessa configuração, o servidor MCP do Codex expõe duas ferramentas: codex() e codex-reply(). É importante entender a diferença para manter o contexto do trabalho.

• Use codex() quando quiser iniciar uma sessão ou tarefa nova.
• Use codex-reply() quando quiser continuar uma conversa existente ou iterar no trabalho recém-feito. Ele exige um parâmetro conversationId para mapear o pedido à conversa certa.

O client_session_timeout_sessions define o tempo máximo que o cliente mantém uma sessão aberta com o servidor MCP STDIO. Definimos um valor alto de 360.000 segundos (100 horas) para o Codex, para que fluxos longos reutilizem a mesma sessão sem cair por inatividade.

Wrappers da comunidade

A comunidade também criou wrappers que facilitam ainda mais. Um projeto notável é o repositório codex-mcp-wrapper no GitHub. Esse wrapper foi feito para integrar o Codex a outros ambientes, como o Claude Code.

Orquestrando um pipeline financeiro multiagente com Codex CLI MCP

Agora que entendemos como rodar o Codex como servidor, vamos ver um cenário real em que isso brilha. Vamos orquestrar um pipeline multiagente em que vários agentes de IA trabalham juntos para acelerar muito a evolução do nosso dashboard financeiro, em comparação com um único agente.

Se o design multiagente parece abstrato, aqui vai uma explicação clara de arquiteturas de agentes e onde setups multiagente realmente ajudam.

Coordenando os agentes de risco e de UI

Neste setup, usamos um script em Python como orquestrador do fluxo. Em vez de pedir a um único agente para fazer tudo, criamos dois especializados:

• Codex-Risk, focado em análise quantitativa
• Codex-UI, focado em implementação de frontend

Como agora rodamos o Codex como um servidor MCP “headless” pelo Agents SDK, tanto o SDK quanto os processos do Codex precisam se autenticar na OpenAI, não só o CLI interativo.

Para manter simples e confiável, garanta que OPENAI_API_KEY (ou opcionalmente CODEX_API_KEY) esteja definida no ambiente antes de rodar o orquestrador, para que todas as partes conversem com os modelos. Rode o comando em um novo terminal:

export OPENAI_API_KEY=<your-key>

Inicializamos dois servidores MCP do Codex independentes em um bloco async with para garantir conexões estáveis e isoladas (um processo por agente), o que realmente permite rodarem em paralelo. Aqui está o script orchestrator.py:

import os
import asyncio
from dotenv import load_dotenv
from agents import Agent, Runner
from agents.mcp import MCPServerStdio


load_dotenv()


async def main():
    async with MCPServerStdio(
        name="Codex-Risk-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            # Codex itself uses your existing auth (codex login / OPENAI_API_KEY)
            "env": {
                # pass through any env you already rely on inside Codex
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_risk_server, MCPServerStdio(
        name="Codex-UI-Server",
        params={
            "command": "npx",
            "args": ["-y", "codex", "mcp-server"],
            "env": {
                "OPENAI_API_KEY": os.getenv("OPENAI_API_KEY", ""),
                "CODEX_API_KEY": os.getenv("CODEX_API_KEY", ""),
            },
        },
        client_session_timeout_seconds=360000,
    ) as codex_ui_server:

        # 1. Define specialized agents (both just use the 'codex' tool)
        risk_agent = Agent(
            name="Codex-Risk",
            instructions=(
                "You are a quant analyst. Use the 'codex' tool to compute VaR and "
                "Sharpe ratio for all positions in the portfolio-dashboard project. "
                "Assume Alpha Vantage integration and volatility logic are already implemented "
                "in the code; reuse and extend that code instead of re-calling external APIs."
            ),
            mcp_servers=[codex_risk_server],
        )

        ui_agent = Agent(
            name="Codex-UI",
            instructions=(
                "You are a frontend developer. Use the 'codex' tool to update the UI in "
                "the portfolio-dashboard project. Your job is to add a VaR (95%) column "
                "to the RiskTable / PortfolioCard views, with clear red/green conditional styling."
            ),
            mcp_servers=[codex_ui_server],
        )

        # 2. Run Risk + UI agents concurrently
        risk_task = Runner.run(
            risk_agent,
            "Compute portfolio VaR (95%) for all positions and write the results into the codebase "
            "in a way that the UI can easily consume (e.g., exported constants or helper functions).",
        )
        ui_task = Runner.run(
            ui_agent,
            "Prepare or update the RiskTable / PortfolioCard components to display a VaR (95%) "
            "column, assuming the risk logic already exists in the project.",
        )

        risk_result, ui_result = await asyncio.gather(risk_task, ui_task)

        print("=== Codex-Risk result ===")
        print(risk_result.final_output)
        print("\n=== Codex-UI result ===")
        print(ui_result.final_output)

        # 3. Optional second pass: let UI agent consume the exact risk output
        followup_ui_result = await Runner.run(
            ui_agent,
            (
                "Now update the UI to wire in the actual VaR values. "
                f"Context from the risk agent: {risk_result.final_output}"
            ),
        )

        print("\n=== Codex-UI follow-up ===")
        print(followup_ui_result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

No mesmo terminal em que você definiu a chave da OpenAI, rode o script de orquestração:

python orchestrator.py

Os agentes vão, de forma independente, consultar a documentação da Alpha Vantage via MCP, buscar dados históricos e escrever a lógica em Python ou TypeScript para calcular o Value at Risk do seu portfólio.

Depois que as duas instâncias do Codex fizerem as mudanças, você pode visualizá-las rodando npm run dev novamente para ver o resultado no navegador. Vai ficar parecido com isto:

Ao separar as responsabilidades, transformamos um processo que levaria uns 20 minutos de vai e vem em um pipeline totalmente automatizado. O agente de Risco cuida da matemática, o de UI cuida da implementação e o dashboard é atualizado em segundos.

Execução paralela de tarefas

A mágica está no modelo de execução. Em uma interface de chat padrão, as chamadas de ferramentas são sequenciais; você precisa esperar buscar os dados para então pedir a atualização do gráfico.

Com MCP e esse approach multiagente, atingimos concorrência real. Enquanto o Codex-Risk espera respostas da API da Alpha Vantage, o Codex-UI já pode estruturar as colunas da tabela e configurar as classes CSS.

Ao dividir as frentes, você sai de buscas de dados brutos para análise de risco complexa e recursos completos de UI em cerca de 5 minutos.

Considerações de segurança e limitações

Como qualquer ferramenta poderosa que conecta seu código ao mundo externo, precisamos falar de segurança. Embora Codex e MCP habilitem capacidades incríveis, também introduzem novas superfícies de ataque e limitações práticas que você deve conhecer antes de usar em produção.

Vulnerabilidades de configuração

O ponto mais crítico envolve o arquivo de configuração. Em versões anteriores do Codex CLI, havia uma vulnerabilidade em que comandos maliciosos podiam ser injetados via config.toml em combinação com um arquivo .env que redirecionava CODEX_HOME para um diretório local. Isso foi corrigido, então é fundamental garantir que você esteja na versão v0.23.0 ou superior.

No entanto, o risco não desaparece só com atualização. Como o Codex respeita configurações por projeto, se você clonar um repositório com um .codex/config.toml malicioso junto de um .env que define CODEX_HOME=./.codex, rodar codex naquela pasta pode executar comandos inesperados definidos ali.

Crie o hábito de auditar o arquivo de configuração de qualquer projeto novo que você clonar. Trate-o com muita cautela antes de rodar qualquer coisa.

Limitações do MCP

Na prática, há algumas arestas. Atualmente, não existe um “teste de conectividade” embutido ao iniciar o CLI. O Codex não avisa automaticamente se um servidor MCP está fora do ar na inicialização. Você precisa basicamente pedir algo como “Check my tools” para o modelo verificar a conexão.

Além disso, embora seja tentador instalar todas as ferramentas disponíveis, é preciso ser seletivo. Se você anexar ferramentas demais, o desempenho do modelo começa a degradar significativamente. Quanto mais ferramentas, mais “ruído” o modelo precisa filtrar, o que pode confundir ou levar a alucinações. É boa prática anexar apenas os servidores MCP de que você precisa.

Codex CLI vs Claude Code

Vale comparar o Codex CLI com seu concorrente direto, o Claude Code.

Se seu objetivo é automação e pipelines de CI, o Codex CLI tende a ser a melhor escolha. É leve, fácil de usar e altamente scriptável. Já o Claude Code brilha como ambiente de codificação interativo dentro do editor, com UX forte para refatorações, testes e assistentes por projeto.

Os estilos de configuração também diferem. O Codex usa TOML, com um ~/.codex/config.toml compartilhado entre CLI e extensão do IDE, além de overrides por projeto via .codex/config.toml em cada repositório. Isso significa que seu ambiente é compartilhado por padrão, mas pode ser customizado por projeto.

O Claude Code normalmente usa configurações baseadas em JSON, com um config global (por exemplo, ~/.claude.json) e arquivos por projeto (como .mcp.json ou configurações do projeto) que permitem a cada repositório definir seus próprios servidores MCP e comportamento, melhorando o isolamento, mas exigindo um pouco mais de setup por repositório.

Embora ambas sejam ferramentas de ponta em agentes de codificação com IA, a escolha depende do seu fluxo: se você imagina o agente vivendo principalmente no terminal ou em jobs de CI, o Codex tende a se encaixar melhor; se você quer um companheiro de código centrado no editor, o Claude Code costuma parecer mais natural.

Para um mergulho mais profundo nessa comparação, recomendo ler nosso guia Codex vs Claude Code.

Conclusão

Cobrimos muita coisa hoje, das definições básicas do MCP à construção do nosso próprio agente Codex. Mas, se for para guardar uma ideia, que seja o poder do fluxo de trabalho em si. O processo inteiro — configurar o servidor MCP, rodar o Codex, e ver as ferramentas descobrirem sozinhas os dados de que precisam — permite construir recursos mais rápido do que um humano conseguiria.

Se você está começando, recomendo não complicar de início. Comece com o Context7 para documentação e talvez apenas um MCP baseado em API, como a Alpha Vantage que montamos hoje. Fique confortável com esse fluxo antes de partir para múltiplos agentes.

Ganhando confiança, o céu é o limite. Explore outros MCPs. Conecte o Figma para gerar código de UI direto dos designs, ou integre o Sentry para o Codex diagnosticar e corrigir bugs em produção automaticamente. Experimente subagentes do Codex e veja quanto do seu trabalho rotineiro dá para delegar. As ferramentas estão aí, são poderosas e estão prontas para você usar.

Se você quer desenvolver aplicações de IA, recomendo se inscrever na nossa trilha de habilidades AI Engineering with LangChain. O conteúdo é nativo em IA: você tem um tutor pessoal que ensina exatamente as competências de que precisa, do seu nível até virar um profissional em engenharia de fluxos de IA.