Estamos à beira de um novo tipo de software. Em sua recente palestra na YC Startup School, Andrej Karpathy descreveu o Software 3.0, um mundo onde a linguagem natural se torna a principal interface de programação, e os grandes modelos de linguagem atuam tanto como motores de computação quanto como colaboradores autônomos.
Diferente do Software 1.0, onde os desenvolvedores escreviam instruções explícitas, ou do Software 2.0, onde redes neurais aprendiam padrões a partir de dados, o Software 3.0 é executado por meio de linguagem natural. Nossos prompts se tornam programas, e os LLMs traduzem nossas intenções em comportamentos executáveis.
Neste tutorial, construiremos um servidor MCP que fornece acesso remoto a uma sandbox da Novita AI onde nosso agente de IA pode executar código com segurança. O próprio agente será criado com a biblioteca mcp-use, que também gerencia a comunicação com o servidor MCP automaticamente.
O que é o MCP (Protocolo de Contexto de Modelo)?
O Protocolo de Contexto de Modelo (MCP) é um padrão aberto desenvolvido pela Anthropic para que modelos de IA se comuniquem com serviços externos, ferramentas e fontes de dados. Pense nele como um “USB-C para IA”; ele fornece uma interface padrão entre agentes e o mundo exterior.
Os três componentes principais:
- Ferramentas: Funções/APIs chamáveis expostas pelo servidor (ex: navegação na web, execução de código).
- Recursos: Dados externos fornecidos pelo servidor, geralmente destinados a servir de contexto para o agente de IA (ex: arquivos, metadados, conjuntos de dados).
- Prompts: Essas instruções detalhadas servem para orientar o comportamento do agente ao interagir com as ferramentas ou recursos acima.
Para uma análise mais aprofundada do MCP, sua arquitetura e componentes, confira nosso blog sobre como construir seu primeiro servidor MCP
Por que o MCP é importante para a integração de ferramentas de IA
O MCP estabelece comunicação bidirecional entre agentes de IA e sistemas externos. Isso facilita a “conexão” de LLMs a ferramentas personalizadas, reduzindo o trabalho de integração e minimizando o potencial de erros.
Introdução à biblioteca mcp-use
A biblioteca mcp-use é um pacote Python que simplifica a construção de agentes de IA que interagem com servidores MCP. Ela gerencia a criação do agente e a comunicação com servidores MCP para acessar ferramentas e fontes de dados externas, permitindo que você se concentre apenas na lógica da sua aplicação.
Visão geral do Novita AI Sandbox e da API de Modelos
O que é uma Sandbox e por que ela é importante
Uma sandbox é um ambiente de execução seguro e isolado onde código não confiável pode ser executado sem afetar o sistema hospedeiro. Ela é basicamente um computador virtual leve para que seu agente de IA execute código, comandos, crie arquivos, etc.
A Novita AI oferece essa sandbox na nuvem para que seu agente acesse rapidamente sob demanda, com faturamento flexível por segundo com base nos recursos utilizados.
Principais recursos da sandbox da Novita:
- Isolamento seguro: Cada sandbox tem seu próprio sistema de arquivos e ambiente isolados, protegendo dados e evitando interações não intencionais.
- Inicialização rápida: As instâncias da sandbox são iniciadas em menos de ~200ms em média, sendo ideais para cenários de baixa latência.
- Suporte a múltiplas linguagens: Você pode executar código em várias linguagens de programação, incluindo Python, JavaScript, TypeScript e outras.
- Pausa e retomada rápidas: Pause a sandbox a qualquer momento e retome quando necessário, com o estado do sistema de arquivos e dos processos totalmente restaurado.
- Execução em segundo plano: Suporta execução de tarefas em segundo plano e é adequada para cenários que exigem espera por um resultado.
API de Modelos da Novita:
A Novita oferece uma vasta biblioteca de modelos de IA de código aberto de laboratórios de pesquisa líderes como OpenAI, Google, DeepSeek e Qwen, entre outros. Esses incluem modelos para linguagem, visão, áudio, vídeo e embeddings. Nossos modelos de linguagem também são totalmente compatíveis com o SDK da OpenAI, então mudar da OpenAI para a Novita requer apenas atualizar a URL base e a chave de API no seu cliente, depois selecionar um modelo da Novita.
| from openai import OpenAI client = OpenAI( base_url=“https://api.novita.ai/v3/openai”, api_key=“ ) |
Configurando seu ambiente de desenvolvimento
Para começar, clonaremos o repositório do GitHub, configuraremos um ambiente Python limpo, instalaremos todas as dependências necessárias e obteremos as chaves da Novita AI.
Clone o repositório do GitHub e instale as dependências com o uv.
1. Instale o uv (um gerenciador de pacotes Python leve)
| pip install uv |
2. Clone o repositório (repositório no GitHub) e navegue até ele.
| git clone https://github.com/Studio1HQ/mcp\_remote\_execution.git cd mcp_remote_execution |
3. Crie e ative o ambiente virtual do uv
| # Creates a virtual environment uv venv # Activate the virtual environment source .venv/bin/activate # For Mac/Linux # or .venv\Scripts\activate # For Windows |
4. Instale as dependências do projeto
| # Install dependencies uv sync |
Criando uma conta na Novita AI e obtendo uma chave de API
1. Cadastre-se em novita.ai.
2. No painel, passe o mouse sobre o ícone de perfil de usuário e clique em API Keys no menu pop-up.
3. Na página de Gerenciamento de Chaves, clique em Add New Key. No pop-up, insira um nome para sua chave, clique em Confirm e depois copie a chave gerada.
4. Agora, dentro do diretório do projeto, crie um arquivo .env e cole o conteúdo abaixo.
| NOVITA_API_KEY=“ NOVITA_BASE_URL=“https://api.novita.ai/v3/openai” NOVITA_E2B_DOMAIN=“sandbox.novita.ai” NOVITA_E2B_TEMPLATE=“code-interpreter-v1” |
Adicione créditos à conta da Novita AI.
Para usar a sandbox da Novita, você precisa adicionar créditos à sua conta. Na aba do painel, clique em ‘Billing’. Depois, na página de faturamento, adicione um método de pagamento e adicione pelo menos $10 em créditos.
Construindo o servidor MCP e a integração com o agente de IA
Agora que nosso ambiente está configurado, vamos começar a construir. Esse processo terá duas partes: primeiro, vamos percorrer a criação do servidor MCP, e depois construiremos a aplicação do agente de IA (que atua como cliente MCP). Mas antes de começarmos, vamos criar o gerenciador de sandbox que o servidor MCP usará.
O Gerenciador de Sandbox
Ele será responsável por iniciar e parar instâncias da sandbox. Em nossa configuração, restringiremos o servidor a uma única instância de sandbox por vez. O Gerenciador de Sandbox também lidará com a execução de código Python e a execução de comandos de shell na sandbox.
Primeiro, no arquivo sandbox_manager.py, temos a classe SandboxManager, que recebe os seguintes parâmetros:
- sandbox_template: O modelo usado para criar uma instância de sandbox. Usaremos o “code-interpreter-v1”, que vem pré-instalado com pacotes Python comumente usados (ex: pandas, numpy).
- sandbox_domain: O endpoint de domínio usado para conectar-se à instância da sandbox da Novita AI.
- sandbox_timeout: A duração (em segundos) que determina por quanto tempo a sandbox permanece ativa antes de ser encerrada automaticamente.
| from novita_sandbox.code_interpreter import Sandbox class SandboxManager: def __init__( self, sandbox_template: str, sandbox_domain: str, sandbox_timeout: int, ): self.sandbox_template = sandbox_template self.sandbox_domain = sandbox_domain self.sandbox_timeout = sandbox_timeout |
Agora adicionaremos métodos para criar e parar uma sandbox.
- Para criação, usamos uma sandbox_api_key, a usamos para iniciar uma nova instância de sandbox para o usuário e retornamos uma mensagem de sucesso com o ID da sandbox ou uma mensagem de exceção se algo der errado.
- Para parar, usamos tanto a sandbox_api_key quanto o sandbox_id, conectamos à sandbox e a paramos se ela existir. Assim como antes, retornamos uma mensagem de sucesso ou de exceção dependendo do resultado.
| … class SandboxManager: … # below existing code def create_sandbox_session(self, sandbox_api_key: str) -> str: “”“ This will create a new sandbox instance. Args: sandbox_api_key (str): The API key for the sandbox. Returns: str: Success message with the sandbox ID of the new sandbox or error message. ”“” try: # create the new sandbox sandbox = Sandbox.create( template=self.sandbox_template, api_key=sandbox_api_key, domain=self.sandbox_domain, timeout=self.sandbox_timeout, ) return f"Successfully created sandbox. Sandbox ID: {sandbox.sandbox_id}“ except Exception as e: return f"Failed to create new sandbox:{str(e)}” def stop_sandbox_session(self, sandbox_api_key: str, sandbox_id: str) -> str: “”“ This will kill a sandbox instance if it exists. Args: sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: str: Success message with the sandbox ID of the killed sandbox or error message. ”“” try: # connect to sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) sandbox.kill() return f"Successfully killed Sandbox ID: {sandbox_id}“ except Exception as e: return f"Failed to kill Sandbox ID: {sandbox_id}\ {str(e)}” |
Por fim, adicionamos métodos para executar código Python e comandos de shell na sandbox de um usuário após conectar-se a ela por meio da chave de API e do ID. Todas as saídas da sandbox (incluindo exceções e erros) são retornadas em um dicionário.
| … class SandboxManager: … # below existing code def run_python_code( self, python_code: str, sandbox_api_key: str, sandbox_id: str ) -> dict: “”“ Runs the python code on the sandbox, and if there any image outputs they are skipped. Args: python_code (str): The python code to run. sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: dict: Containing stdout, logs, error, etc. ”“” try: # connect to sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) execution = sandbox.run_code(python_code, language=“python”) return { # we will skip image outputs. “outputs”: [result for result in execution.results if not result.png], “logs”: execution.logs, “error”: execution.error, } except Exception as e: return {“error”: str(e)} def run_on_command_line( self, command: str, sandbox_api_key: str, sandbox_id: str ) -> dict: “”“ Runs the command on the sandbox. Args: command (str): The command to run. sandbox_api_key (str): The API key for the sandbox. sandbox_id (str): The ID of the sandbox. Returns: dict: Containing the output of the command and the execution error if any. ”“” try: # connect to sandbox sandbox = Sandbox.connect( api_key=sandbox_api_key, sandbox_id=sandbox_id, ) result = sandbox.commands.run(command) return { “output”: { “stdout”: result.stdout, “stderr”: result.stderr, “exit_code”: result.exit_code, “error”: result.error, }, “execution error”: None, } except Exception as e: return {“output”: None, “execution error”: str(e)} |
Criando o servidor MCP
Agora que o Gerenciador de Sandbox está configurado, é hora de trabalhar no mcp_server.py. Primeiro, criamos uma instância do FastMCP, o framework que executará o servidor, juntamente com um Gerenciador de Sandbox. Também criamos uma instância de console rich para impressão bonita no terminal.
Nota: O tempo limite da sandbox passado para o Gerenciador de Sandbox é usado para todas as sandboxes iniciadas neste servidor. É o tempo máximo (em segundos) que cada sandbox pode permanecer ativa (em execução), a menos que seja parada mais cedo.
| import asyncio import os from dotenv import load_dotenv from mcp.server.fastmcp import Context, FastMCP from rich.console import Console from rich.panel import Panel from rich.table import Table from starlette.requests import Request from sandbox_manager import SandboxManager # load .env variables load_dotenv() console = Console() # Initialize FastMCP server mcp = FastMCP(“MCP_Server”) # Initialize sandbox manager for the singleton sandbox instance. sandbox_manager = SandboxManager( sandbox_template=os.getenv(“NOVITA_E2B_TEMPLATE”), sandbox_domain=os.getenv(“NOVITA_E2B_DOMAIN”), sandbox_timeout=900, # 900 seconds (15 minutes), sandbox instance will be killed automatically after. ) |
Agora, como precisamos de uma chave de API para conectar-se à sandbox de um usuário, vamos obtê-la da solicitação do usuário ao servidor. Como veremos mais tarde no cliente MCP, essa chave será enviada no cabeçalho de autorização de todas as solicitações. Isso significa que precisamos de uma maneira de extrair a chave de API desse cabeçalho no lado do servidor.
O FastMCP fornece um objeto Context que, em tempo de execução, armazena informações sobre o usuário que faz a solicitação. Portanto, criaremos um método auxiliar get_user_api_key que recebe um objeto de contexto, extrai a chave de API do cabeçalho e a retorna ou lança uma exceção se ela estiver ausente.
| … # below existing code def get_user_api_key(ctx: Context) -> str: “”“ Returns the API key from the request header if it exists otherwise raise an exception. ”“” request: Request = ctx.request_context.request # Access request data auth_header = request.headers.get(“Authorization”) if auth_header: auth_header = auth_header.split(" ")[1] if not auth_header: raise Exception(“Missing API Key in Authorization Bearer header”) return auth_header |
Chegou a hora de expor prompts, ferramentas e recursos em nosso servidor. Para fazer isso, basta adicionar o decorador @mcp.{prompt, tool, resource}() à função Python. Começando pelo nosso prompt, que retorna instruções sobre como nosso agente deve usar a sandbox.
| … # below existing code (Note: Console display helper methods were skipped for brevity) @mcp.prompt() def instructions_for_sandbox_use() -> str: “”“ RETURNS MUST READ INSTRUCTIONS FOR SANDBOX USE. ”“” return “”“ When you want to use the sandbox function, you must first create a new sandbox session by calling the create_sandbox_session() function. Then you can use the run_python_code() or run_on_command_line() function to run on the sandbox. When you are done, you must kill the sandbox session by calling the stop_sandbox_session() function. Note: - The sandbox already comes pre-installed with the usual data analysis packages but if there’s a package you are not sure exists or your code had an import error due to a missing package, you can check if it’s installed and if not install it. ”“” |
Para as ferramentas, expomos métodos que usam a instância do sandbox_manager para criar, parar e executar código ou comandos na sandbox de um usuário.
Nota: Entre os argumentos que os métodos de ferramenta abaixo recebem, incluiremos um ctx: Context. Isso informa ao FastMCP para inserir automaticamente o contexto da solicitação nesse parâmetro, um processo conhecido como injeção de dependência. Depois, obtemos a chave de API, se ela existir, passando esse contexto para nosso método auxiliar (get_user_api_key).
| … # below existing code @mcp.tool() def create_sandbox_session(ctx: Context) -> str: “”“ This will create a sandbox instance and return success message with the sandbox id or error message. ”“” try: return sandbox_manager.create_sandbox_session(get_user_api_key(ctx)) except Exception as e: return e @mcp.tool() def stop_sandbox_session(sandbox_id: str, ctx: Context) -> str: “”“ This will kill a sandbox instance if it exists. ”“” try: return sandbox_manager.stop_sandbox_session(get_user_api_key(ctx), sandbox_id) except Exception as e: return e @mcp.tool() def run_python_code(python_code: str, sandbox_id: str, ctx: Context) -> dict: “”“ Runs the python code on the sandbox, and if there any image outputs they are skipped. Args: python_code (str): The python code to run. sandbox_id (str): The ID of the sandbox. Note: The ctx (Context) is a dependency injection object that is automatically passed. Returns: dict: Containing stdout, logs, error, etc. ”“” console.print( Panel( python_code, title=“Agent Executing Python Code”, border_style=“blue”, ) ) try: result = sandbox_manager.run_python_code( python_code, get_user_api_key(ctx), sandbox_id ) # display the result. Note: only do this in test not in prod. display_sandbox_code_output(result) return result except Exception as e: return {“error”: str(e)} @mcp.tool() def run_on_command_line(command_line: str, sandbox_id: str, ctx: Context) -> dict: “”“ Runs the command on the sandbox. Args: command_line (str): The command to run. sandbox_id (str): The ID of the sandbox. Note: The ctx (Context) is a dependency injection object that is automatically passed. Returns: dict: Containing the output of the command and the execution error if any. ”“” console.print( Panel( command_line, title=“Agent Executing Command Line”, border_style=“blue”, ) ) try: result = sandbox_manager.run_on_command_line( command_line, get_user_api_key(ctx), sandbox_id ) # display the result. Note: only do this in test not in prod. display_sandbox_command_output(result) return result except Exception as e: return {“execution error”: str(e)} |
Agora exporemos um único recurso para um dos nossos cenários de demonstração, que veremos mais tarde. Esse recurso retorna uma simulação da carteira de ações de um usuário. Diferente de prompts e ferramentas, os recursos exigem a especificação de uma URL onde eles estarão acessíveis.
| … # below existing code @mcp.resource(“data://user_stock_portfolio”) def get_user_portfolio() -> dict: “”“ Returns the user’s portfolio holdings across major index ETFs and individual stocks. Returns: dict: Portfolio with ticker symbols, quantities, and average purchase prices ”“” portfolio = { “holdings”: [ # Major Index ETFs { “ticker”: “SPY”, “name”: “SPDR S&P 500 ETF”, “quantity”: 4, “avg_purchase_price”: 670.13, “asset_type”: “ETF”, }, … # skipped for brevity ] } return portfolio |
Por fim, adicionamos o código que inicia nosso servidor. Não usaremos o transporte mcp stdio porque o console Rich imprime no terminal, o que é uma operação de bloqueio que interferiria. Em vez disso, usaremos o transporte mcp streamable-http (é isso que você também usará em produção, pois é o mais adequado para conexões remotas entre cliente e servidor por HTTP).
| … # below existing code if __name__ == “__main__”: # run the server # Note: We use streamable-http as the transport protocol instead of stdio because we are printing to the console which would block stdio. # Also in production you should use SSE or streamable-http rather than stdio. asyncio.run(mcp.run(transport=“streamable-http”)) |
Ufa, vamos iniciar nosso servidor MCP para obter a URL em que ele está rodando, que precisaremos para conectar nosso agente de IA. Execute o comando abaixo no terminal.
| uv run mcp_server.py |
Você verá o servidor rodando agora. Anote a URL em que ele está operando
Integrando o Agente de IA com o Servidor MCP
Agora vamos começar a trabalhar no agente de IA no arquivo mcp_client.py. A biblioteca mcp-use facilita esse processo. Primeiro, definimos o nível de depuração como INFO para ver o que o agente está fazendo. No método principal, criamos um dicionário de configuração para o cliente mcp. Ele especifica os servidores mcp disponíveis, usando um nome (usei “stock&sandbox”) e a URL em que o servidor mcp está rodando (lembre-se de adicionar /mcp), também incluímos a chave de API do usuário como valor para “auth”, que será inserida automaticamente pelo mcp-use no cabeçalho de autorização Bearer de todas as solicitações.
Como o mcp-use depende do langchain-openai, passamos a URL base da Novita, a chave de API e o nome do modelo LLM, o que funciona porque a Novita é compatível com a OpenAI.
E além da resposta do agente, gostaríamos de incluir o ID da sandbox que ele usou no servidor, se houver (explicaremos o motivo mais tarde). Para fazer isso, definiremos uma classe Pydantic para representar nosso formato de resposta.
| import asyncio import os from datetime import datetime from typing import Optional import mcp_use from dotenv import load_dotenv from langchain_openai import ChatOpenAI from mcp_use import MCPAgent, MCPClient from pydantic import BaseModel, Field from rich.console import Console from rich.panel import Panel from rich.prompt import Prompt # Load environment variables load_dotenv() console = Console() # Note: 1 for INFO level, 2 for full verbose DEBUG level and 0 for NO debug output. mcp_use.set_debug(1) class ResponseFormat(BaseModel): response: str id_of_used_sandbox: Optional[str] = Field( …, description=“The id of the sandbox used if any” ) async def main(model: str, base_url: str, api_key: str): # Create configuration dictionary config = { “mcpServers”: { “stock&sandbox”: { # If the url the mcp server is running at is different replace below, # also remember to add /mcp. “url”: “http://127.0.0.1:8000/mcp”, “auth”: api_key, } } } # Create MCPClient from configuration dictionary client = MCPClient(config) # Create LLM llm = ChatOpenAI(model=model, base_url=base_url, api_key=api_key) … |
Depois, criamos o agente MCP passando o LLM, o cliente MCP, o número máximo de passos (que limita as ações que o agente pode executar antes de responder) e ativando a memória para que o mcp-use gerencie nosso histórico de conversa. Também fornecemos um prompt de sistema que inclui a data e hora atuais, juntamente com instruções personalizadas para usar a sandbox (adicionei isso porque alguns modelos esquecem de ler os prompts de instrução expostos no servidor).
Por fim, configuramos o loop de conversa padrão: obtemos a entrada do usuário, a passamos para agent.run() e imprimimos a resposta. Se uma sandbox foi usada, criamos uma sessão para chamar manualmente o método de parada no servidor como medida de segurança, caso o modelo esqueça de fechá-la.
| … async def main(model: str, base_url: str, api_key: str): … # below existing code # Create agent with the client agent = MCPAgent( llm=llm, client=client, max_steps=25, memory_enabled=True, # mcp-use will auto handle the conversation history. system_prompt=f"“” You are a helpful assistant and the current date is {datetime.now().strftime(‘%Y-%m-%d’)} MUST REMEMBER: - Before any tool call first call instructions_for_sandbox_use() so you can read them. - Ensure you call stop_sandbox_session() after using the sandbox before responding to the user. “”“, ) console.print( Panel( ”[bold green]MCP Session Started[/bold green]\ Type ‘quit()’ to exit.“, title=“MCP Session”, border_style=“green”, ) ) while True: user_input = Prompt.ask(”\ [bold yellow]>>> User Message[/bold yellow]“) if user_input.lower().strip() == “quit()”: break # Pass the query to the agent and await the response. response_obj = await agent.run(user_input, output_schema=ResponseFormat) console.print( f”\ [bold green]>>> Assistant Response: {response_obj.response} [/]" ) if response_obj.id_of_used_sandbox: # Will trigger closure of sandbox on MCP server if it sill active. session = await client.create_session(“stock&sandbox”) await session.call_tool( name=“stop_sandbox_session”, arguments={“sandbox_id”: response_obj.id_of_used_sandbox}, ) await session.disconnect() |
Por último, adicionamos o código que inicia o cliente:
| … # below existing code if __name__ == “__main__”: asyncio.run( main( model=“qwen/qwen3-coder-480b-a35b-instruct”, base_url=os.getenv(“NOVITA_BASE_URL”), api_key=os.getenv(“NOVITA_API_KEY”), ) ) |
Testando a execução do nosso Agente de IA MCP:
Você pode iniciar a aplicação do agente de IA executando o comando abaixo no terminal
| uv run mcp_client.py |
Abaixo estão os links de vídeo das demonstrações de execução para os seguintes prompts:
- Prompt do Usuário 1: “Tenho $2.000. Obtenha o desempenho dos principais índices de ações dos EUA no yfinance nos últimos 6 meses e execute modelos de ML para prever como alocar esse investimento para maximizar os retornos potenciais nos próximos 2 meses.” (Insira o link aqui)
- Prompt do Usuário 2: “Execute múltiplas simulações de uma crise de deflação econômica nos EUA, escolha a mais provável e explique o impacto que ela terá na minha carteira de ações.” (Insira o link aqui)
Dicas para servidores MCP em produção
Embora este tutorial tenha se concentrado na construção de um servidor MCP funcional com o Novita Sandbox, a implantação em produção requer considerações adicionais:
Use o transporte correto: Enquanto o “stdio” funciona para desenvolvimento local, servidores MCP de produção devem usar o “streamable-http” para permitir conexões remotas, assim como fizemos acima.
Implemente autenticação: Assim como fizemos acima, certifique-se de proteger os endpoints do seu servidor mcp com autenticação. Garanta que cada cliente tenha permissão apenas para acessar as ferramentas e recursos de que precisa. Você pode ler mais sobre métodos de autenticação em Autenticação no FastMCP
Ative o registro de logs: Use um logger para monitorar a atividade do servidor, depurar problemas e rastrear padrões de uso. Isso é vital para manutenção e solução de problemas.
Limitação de taxa e cotas: Proteja seu servidor contra abusos implementando limites de taxa e cotas. Isso é especialmente importante ao expor ferramentas que consomem muitos recursos.
Documentação e versionamento: Mantenha uma documentação clara da API do seu servidor MCP e do versionamento para facilitar a integração por desenvolvedores e LLMs.
Conclusão
Ufa, agora você finalmente pode construir um servidor MCP onde agentes de IA podem executar código remotamente por meio de instruções em linguagem natural, uma implementação prática do Software 3.0 em ação.
Neste tutorial, você aprendeu a construir um servidor MCP com capacidade de execução de código, gerenciar ciclos de vida de sandboxes e criar um agente de IA usando o mcp-use que se conecta ao seu servidor. Em seguida, tente estendê-lo com acesso a bancos de dados, pesquisa na web ou vinculando vários servidores a um único agente. Acesse a Novita, temos as ferramentas que você precisa para construir seus agentes de IA.
A Novita AI é uma plataforma de nuvem de IA que oferece aos desenvolvedores uma maneira fácil de implantar modelos de IA usando nossa API simples, além de fornecer uma nuvem de GPU acessível e confiável para construção e escalonamento.
