mcp-use: A Revolucionária Biblioteca Python para Agentes MCP e LLMs

No dinâmico universo da programação e inteligência artificial, surge uma nova ferramenta promissora: a biblioteca mcp-use. Trata-se de uma solução em Python, open-source, projetada para simplificar e unificar a maneira como desenvolvedores interagem com servidores MCP (Multi-Content Prompt) e diversos Modelos de Linguagem de Grande Escala (LLMs). Este artigo explora em detalhes o que é o mcp-use, como instalá-lo, configurá-lo e utilizá-lo para criar agentes personalizados e poderosos, transformando a interação com LLMs em seus projetos.

O que é o mcp-use?

O mcp-use é uma biblioteca Python que atua como uma ponte, permitindo que qualquer LLM (como os modelos da OpenAI ou Anthropic) se comunique de forma eficiente com qualquer servidor MCP. Antes dessa biblioteca, a comunicação com servidores MCP frequentemente exigia o uso de clientes específicos, como Windsurf, Cursor ou o Claude Desktop. O mcp-use elimina essa necessidade, oferecendo uma interface unificada e programática diretamente no seu código.

A principal proposta do mcp-use é permitir que desenvolvedores conectem facilmente LLMs a ferramentas, como navegação web, operações de arquivo e muito mais, através de agentes MCP. Isso abre um leque de possibilidades para a criação de agentes customizados que podem executar tarefas complexas de forma autônoma, utilizando a inteligência do LLM escolhido e as capacidades do servidor MCP.

Instalação e Configuração do mcp-use

A instalação e configuração do mcp-use envolvem alguns passos essenciais, desde a preparação do ambiente Python até a configuração das chaves de API para os LLMs.

Pré-requisitos: Python e Ambiente Virtual com mcp-use

Antes de instalar o mcp-use, é crucial ter o Python instalado em seu sistema. Você pode verificar a instalação com o comando python --version ou python3 --version no terminal. Recomenda-se o uso de Python 3.

Para manter as dependências do projeto isoladas, é uma boa prática criar um ambiente virtual:

1. Crie o ambiente virtual: python3 -m venv venv
2. Ative o ambiente virtual:
   • No macOS/Linux: source venv/bin/activate
   • No Windows: .\venv\Scripts\activate

Instalando a Biblioteca mcp-use

Com o ambiente virtual ativado, instale a biblioteca mcp-use utilizando o pip, o gerenciador de pacotes do Python:

pip3 install mcp-use

O uso do pip3 é importante para garantir que a instalação seja feita para a versão correta do Python, caso haja múltiplas versões no sistema.

Configurando Provedores de LLM com mcp-use

O mcp-use integra-se com LLMs através da popular biblioteca LangChain. Portanto, você precisará instalar os pacotes LangChain correspondentes ao provedor de LLM que deseja usar:

• Para OpenAI: pip install langchain-openai
• Para Anthropic (Claude): pip install langchain-anthropic

Para outros provedores, como Grok ou Llama, é recomendável consultar a documentação oficial do LangChain sobre integrações de modelos de chat para encontrar os pacotes necessários.

Configurando Chaves de API para mcp-use

Para que o mcp-use possa interagir com os LLMs, você precisará fornecer as chaves de API. A maneira recomendada é criar um arquivo chamado .env na raiz do seu projeto e adicionar suas chaves lá. Por exemplo, para a OpenAI:

OPENAI_API_KEY=SUA_CHAVE_DE_API_AQUI

Se estiver usando Anthropic, adicione também:

ANTHROPIC_API_KEY=SUA_CHAVE_DE_API_AQUI

Substitua SUA_CHAVE_DE_API_AQUI pela sua chave real. O mcp-use, através da biblioteca python-dotenv, carregará essas variáveis de ambiente automaticamente.

Utilizando o mcp-use na Prática: Um Exemplo com Airbnb

Para ilustrar o funcionamento do mcp-use, o vídeo de demonstração utiliza um exemplo prático com um servidor MCP do Airbnb. Este exemplo mostra como criar um agente que busca acomodações com base em um prompt.

Estrutura do Código de Exemplo com mcp-use

O código de exemplo para interagir com o MCP do Airbnb usando mcp-use e OpenAI GPT-4o seria estruturado da seguinte forma:

import asyncio
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from mcp_use import MCPAgent, MCPClient

async def run_airbnb_example():
    # Carrega variáveis de ambiente do arquivo .env
    load_dotenv()

    # Cria o MCPClient a partir de um arquivo de configuração JSON
    # Este arquivo define como o servidor MCP do Airbnb será iniciado
    client = MCPClient.from_config_file(
        os.path.join(os.path.dirname(__file__), "airbnb_mcp.json")
    )

    # Define o LLM a ser utilizado (neste caso, GPT-4o da OpenAI)
    llm = ChatOpenAI(model="gpt-4o")

    # Cria o MCPAgent, vinculando o LLM ao cliente MCP
    # max_steps define o número máximo de interações que o agente pode realizar
    agent = MCPAgent(llm=llm, client=client, max_steps=30)

    try:
        # Executa uma consulta para buscar acomodações
        result = await agent.run(
            "Encontre um bom lugar para ficar em Barcelona para 2 adultos "
            "por uma semana em agosto. Prefiro lugares com piscina e "
            "boas avaliações. Mostre-me as 3 melhores opções.",
            max_steps=30
        )
        print(f"\nResultado: {result}")
    finally:
        # Garante que os recursos sejam limpos adequadamente
        if client.sessions:
            await client.close_all_sessions()

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

O arquivo airbnb_mcp.json mencionado no código conteria a configuração para iniciar o servidor MCP do Airbnb, especificando o comando e os argumentos necessários, como por exemplo:

{
  "mcpServers": {
    "airbnb": {
      "command": "npx",
      "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"]
    }
  }
}

Executando o Código mcp-use

Para executar este script (supondo que se chame agent.py), você usaria o comando no terminal:

python agent.py

Após a execução, o agente MCP, alimentado pelo LLM, interagiria com o servidor MCP do Airbnb para buscar as acomodações conforme o prompt, e o resultado (as listagens encontradas) seria impresso no console. O vídeo demonstra que, mesmo com alguns erros de sintaxe JSON no output do servidor (que podem ocorrer), o agente conseguiu processar a informação e retornar os links das acomodações que atendiam aos critérios, como ter piscina e boas avaliações.

Recursos Adicionais e Dicas para mcp-use

O mcp-use oferece flexibilidade e pode ser integrado com outras ferramentas para um desenvolvimento mais eficiente.

Integração com Cursor e Documentação para mcp-use

Para desenvolvedores que utilizam o editor de código Cursor, é possível aprimorar a experiência de desenvolvimento. O Cursor permite adicionar documentações personalizadas para fornecer contexto ao seu assistente de IA. Você pode adicionar o link do arquivo README.md do repositório GitHub do mcp-use na seção 'Docs' das configurações do Cursor. Isso permitirá que o Cursor entenda melhor o framework mcp-use e ofereça sugestões de código mais precisas e relevantes.

Utilizando o GitIngest para Entender Repositórios com mcp-use

Caso precise de uma compreensão mais aprofundada de um repositório GitHub, como o próprio mcp-use ou outros que você queira integrar, a ferramenta GitIngest pode ser útil. Ao substituir `github.com` por `gitingest.com` na URL de um repositório (por exemplo, o README), o GitIngest converte o conteúdo do repositório em um formato textual legível por LLMs. Isso facilita a análise e a obtenção de respostas sobre o funcionamento do código, sendo uma excelente forma de esclarecer dúvidas.

Recursos Avançados do mcp-use

A documentação do mcp-use, disponível no repositório GitHub, detalha funcionalidades mais avançadas, incluindo:

• Suporte a Conexão HTTP: Permite conectar-se a servidores MCP que rodam em portas HTTP específicas, útil para integrar com servidores web-based.
• Suporte Multi-Servidor: Configurar e conectar-se a múltiplos servidores MCP simultaneamente usando um único `MCPClient`. Isso habilita fluxos de trabalho complexos que exigem ferramentas de diferentes servidores.
• Seleção Dinâmica de Servidor (Server Manager): Ao habilitar o `use_server_manager=True` na inicialização do `MCPAgent`, o agente pode selecionar inteligentemente o servidor MCP correto com base na ferramenta escolhida pelo LLM para uma etapa específica, otimizando conexões.
• Controle de Acesso a Ferramentas: Permite restringir quais ferramentas estão disponíveis para o agente, oferecendo maior segurança e controle sobre as capacidades do agente.

Conclusão sobre o mcp-use

A biblioteca mcp-use representa um avanço significativo para desenvolvedores que buscam criar agentes de IA mais sofisticados e integrados. Sua capacidade de unificar a comunicação com diversos servidores MCP e LLMs, juntamente com sua natureza open-source e flexibilidade, abre um vasto campo para a inovação.

Seja para automatizar tarefas, criar assistentes virtuais mais inteligentes ou explorar novas fronteiras da interação homem-máquina, o mcp-use oferece uma base sólida e promissora. Encorajamos a comunidade de desenvolvedores a explorar esta ferramenta, contribuir para seu desenvolvimento e compartilhar as incríveis aplicações que certamente surgirão.