Application Real-Time Monitoring Service:Implementar rastreamento de ponta a ponta com base no protocolo MCP

Contexto

No desenvolvimento moderno de aplicações de IA, a observabilidade tornou-se essencial. À medida que as arquiteturas das aplicações se tornam mais complexas, os desenvolvedores precisam de insights profundos sobre o status da aplicação, gargalos de desempenho e possíveis problemas. Os métodos tradicionais de monitoramento frequentemente exigem configurações manuais extensas e alterações no código, o que aumenta os custos de desenvolvimento e pode introduzir novos erros.

O Model Context Protocol (MCP) é um padrão aberto introduzido pela Anthropic. Se um agente de IA funciona como um assistente inteligente, o MCP atua como sua caixa de ferramentas versátil. Ele integra recursos como consultas a bancos de dados, chamadas de API, operações de I/O de arquivos e envio de e-mails. Com o MCP, o agente de IA evolui de um assistente conversacional inteligente para um assistente de execução multiuso, capaz de concluir tarefas complexas do mundo real.

No entanto, ao usar agentes com MCP, os desenvolvedores frequentemente enfrentam os seguintes pontos críticos:

• Pontos cegos na seleção de ferramentas

  Diante de tarefas complexas, o agente pode escolher uma ferramenta inadequada, resultando em baixa eficiência ou resultados imprecisos. Além disso, os desenvolvedores carecem de ferramentas de visualização para analisar o processo de tomada de decisão do agente e a lógica de seleção de ferramentas.

• Dificuldade na solução de erros

  Erros nas chamadas de ferramentas, como formatos de parâmetros incorretos, incompatibilidade de tipos ou ausência de parâmetros obrigatórios, costumam ficar ocultos em cadeias de chamadas complexas. Isso dificulta a localização rápida da causa raiz do problema.

• Consumo excessivo de tokens

  Múltiplas rodadas de interação entre um agente e as ferramentas MCP podem levar facilmente a um consumo de tokens inesperadamente alto. A falta de monitoramento de custos em tempo real pode causar estouro de orçamento. Também é difícil entender o consumo de tokens das diferentes ferramentas MCP, o que torna desafiadora a otimização precisa de custos.

• Armadilhas de invocação recursiva

  Um agente pode ficar preso em um loop, chamando repetidamente a mesma ferramenta. Sem métodos adequados para detectar e interromper esse comportamento anormal, há desperdício de recursos.

O ARMS oferece um agente Python poderoso e pronto para uso, que adiciona observabilidade completa às aplicações Python sem intrusão no código. Para resolver esses pontos críticos ao usar o MCP, a versão mais recente do agente Python do ARMS inclui suporte à observabilidade para o protocolo MCP. Isso faz dele a primeira solução a fornecer monitoramento profissional e unificado para o protocolo MCP.

• Integração sem código: Obtenha monitoramento completo e pronto para uso de aplicações de IA sem nenhuma modificação no código.

• Visualização do processo de seleção de ferramentas: Integra-se profundamente ao protocolo MCP para fornecer uma visualização da seleção de ferramentas e do processo de chamada do agente de IA.

• Localização precisa de falhas: Em caso de anomalia no sistema, utilize as informações de rastreamento para localizar rapidamente a causa raiz do problema.

• Análise de custos de tokens: Fornece monitoramento preciso do uso de tokens de modelos grandes e dos dados de custos associados.

• Rastreamento de ponta a ponta: Exibe a cadeia completa de chamadas, desde a consulta do usuário até as chamadas do agente e do MCP, permitindo identificar rapidamente padrões de chamada anormais.

Arquitetura do cenário de demonstração

Esta seção descreve como criar um assistente inteligente de análise de logs para demonstrar como o agente Python do ARMS monitora uma aplicação de IA baseada no protocolo MCP.

Primeiro, utilize o framework LangChain para criar um agente. Quando um usuário envia uma consulta ao agente, este usa o modelo grande Qwen Turbo para planejar e executar as etapas necessárias para resolver o problema. Durante a execução, o agente utiliza o protocolo MCP para acessar o servidor SLS MCP. O servidor SLS MCP, por sua vez, usa a OpenAPI HTTP do SLS para acessar a API do Simple Log Service e concluir a solicitação de análise de logs.

O ARMS coleta automaticamente os dados de telemetria gerados pelo agente LangChain e pelo servidor SLS MCP durante a solicitação. Em seguida, analise os dados coletados no console do ARMS.

Instalação e configuração do ambiente

export ARMS_APP_NAME=xxx   # The application name.
export ARMS_REGION_ID=xxx   # The region ID of your Alibaba Cloud account.
export ARMS_LICENSE_KEY=xxx   # Your Alibaba Cloud license key.
export ARMS_IS_PUBLIC=True   # Add this environment variable to access ARMS over the Internet.
export BALIAN_API_KEY=sk-************   # The Model Studio API key.

# Install project dependencies
pip install mcp==1.10.1 langchain-mcp-adapters langgraph "langchain[openai]" aliyun-bootstrap rich mcp_server_aliyun_observability -y

# Install the ARMS Python agent
aliyun-bootstrap -a install

Demonstração

aliyun-instrument python -m mcp_server_aliyun_observability \
  --transport sse \
  --access-key-id <Your Alibaba Cloud AccessKey ID> \
  --access-key-secret <Your Alibaba Cloud AccessKey secret>

Load Aliyun python agent version: 1.6.1

from contextlib import asynccontextmanager
from mcp import ClientSession
from mcp.client.sse import sse_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
import asyncio
from opentelemetry import trace
import os

tracer = trace.get_tracer(__name__)

# Create a large model object
model = ChatOpenAI(
    model="qwen-turbo",
    api_key=os.getenv("BALIAN_API_KEY"),  # Model Studio API key
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# Create an agent
@asynccontextmanager
async def sls_agent():
    with tracer.start_as_current_span("langchain-demo"):
        async with sse_client(url="http://0.0.0.0:8000/sse") as (read, write):
            async with ClientSession(read, write) as session:
                await session.initialize()
                tools = await load_mcp_tools(session)
                agent = create_react_agent(model, tools)
                yield agent

def print_response(response):
    for message in response['messages']:
        print(message.content)

async def main():
    # Create an SLS agent
    async with sls_agent() as agent:
        # Call the model to process the query
        response = await agent.ainvoke(
            {"messages": "I want to query the list of my projects in the Hangzhou region and get the first 10."}
        )
        print_response(response)

        # Ask a follow-up question
        response = await agent.ainvoke(
            {
                "messages": "Query the logs in the loghub_master Logstore of the demo-test project in the Hangzhou region, and analyze how many logs were written in the last ten minutes."
            }
        )
        print_response(response)

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

I want to query the list of my projects in the Hangzhou region and get the first 10.

The following are the first 10 projects in the Hangzhou (cn-hangzhou) region:

1. sls-aysls-pub-cn-hangzhou-b-xxxx
2. e2e-test-xxxx
3. workspace-xxxx
4. ws-xxxx (Description: Created by o11y)
5. clickbench8 (Description: clickbench8)
6. clickbench16 (Description: clickbench16)
7. clickbench (Description: clickbench)
8. job-e2e-project-xxxx
9. job-e2e-project-xxxx
10. job-e2e-project-xxxx
To query more projects, you can provide keywords for a fuzzy search.

Query the logs in the loghub_master Logstore of the demo-test project in the Hangzhou region, and analyze how many logs were written in the last ten minutes.

In the last ten minutes, a total of **8,641 logs** were written to the `loghub_master` Logstore in the `demo-test` project.

A demonstração anterior é um exemplo simples que mostra apenas a integração do MCP com um agente de IA. Para obter mais informações sobre cenários de análise de logs do SLS, consulte alibabacloud-observability-mcp-server.

Visualizar a cadeia de chamadas do MCP

1. No console do ARMS, acesse a página Application Monitoring > Applications e clique em no nome da aplicação Python alvo.

2. Na página Tracing Analysis, clique em na aba Traces e, em seguida, clique em em um Trace ID para analisar a chamada.

   

   A página Detalhes do Rastreamento exibe as informações completas de rastreamento de um processo de invocação. Os detalhes abaixo mostram que o Agente de IA chama o Cliente MCP para acessar a API do Simple Log Service. O Cliente MCP então envia a solicitação ao Servidor MCP, que, por sua vez, acessa o Simple Log Service usando uma API HTTP. O tempo total gasto foi de 66 ms.

   

3. Clique em em um span. No painel à direita, visualize mais detalhes, como o endpoint, protocolo da solicitação, parâmetros da solicitação e tamanho do corpo da resposta.

4. Na aba Metrics, visualize as métricas associadas à solicitação para analisar melhor o throughput, a latência e outros indicadores.