Symbolic Algebra MCP Server

Realize matemática

Documentação

Servidor MCP de Álgebra Simbólica

Sympy-MCP é um servidor de Protocolo de Contexto de Modelo (MCP) que permite que LLMs realizem matemática simbólica e álgebra computacional de forma autônoma. Ele expõe diversas ferramentas da funcionalidade central do SymPy para clientes MCP, permitindo a manipulação de expressões matemáticas e equações.

Por quê?

Modelos de linguagem são absolutamente péssimos em manipulação simbólica. Eles alucinam variáveis, inventam constantes aleatórias, permutam termos e, no geral, fazem uma bagunça. Mas nós temos sistemas de álgebra computacional construídos especificamente para manipulação simbólica, então podemos usar chamadas de ferramentas para orquestrar uma sequência de transformações, de modo que o kernel simbólico faça todo o trabalho pesado.

Embora você certamente possa fazer um LLM gerar código Mathematica ou Python, se quiser usar o LLM como um agente ou calculadora em tempo real, é uma experiência melhor usar o servidor MCP e expor as ferramentas simbólicas diretamente.

O servidor expõe um subconjunto de capacidades de matemática simbólica, incluindo resolução de equações algébricas, integração e diferenciação, cálculo vetorial, cálculo tensorial para relatividade geral, e equações diferenciais ordinárias e parciais.

Por exemplo, você pode pedir em linguagem natural para resolver uma equação diferencial:

Resolva o oscilador harmônico amortecido com termo de forçamento: o sistema massa-mola-amortecedor descrito pela equação diferencial onde m é a massa, c é o coeficiente de amortecimento, k é a constante da mola, e F(t) é uma força externa.

$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$

Ou envolvendo relatividade geral:

Calcule o traço do tensor de Ricci $R_{\mu\nu}$ usando a métrica inversa $g^{\mu\nu}$ para o espaço-tempo Anti-de Sitter para determinar sua curvatura escalar constante $R$.

Uso

Você precisa do uv primeiro.

Homebrew : brew install uv
Curl : curl -LsSf https://astral.sh/uv/install.sh | sh

Então você pode instalar e executar o servidor com os seguintes comandos:

# Setup the project
git clone https://github.com/sdiehl/sympy-mcp.git
cd sympy-mcp
uv sync

# Install the server to Claude Desktop
uv run mcp install server.py

# Run the server
uv run mcp run server.py

Você deve ver o servidor disponível no aplicativo Claude Desktop agora. Para outros clientes, veja abaixo.

Se você quiser uma versão completamente autônoma que apenas executa com um único comando, você pode usar o seguinte. Nota: isso executa código arbitrário do Github, então tenha cuidado.

uv run --with https://github.com/sdiehl/sympy-mcp/releases/download/0.1/sympy_mcp-0.1.0-py3-none-any.whl python server.py

Se você quiser fazer cálculos de relatividade geral, você precisa instalar a biblioteca einsteinpy.

uv sync --group relativity

Ferramentas Disponíveis

O servidor sympy-mcp fornece as seguintes ferramentas para matemática simbólica:

Ferramenta	ID da Ferramenta	Descrição
Introdução de Variável	`intro`	Introduz uma variável com suposições especificadas e a armazena
Múltiplas Variáveis	`intro_many`	Introduz múltiplas variáveis com suposições especificadas simultaneamente
Analisador de Expressão	`introduce_expression`	Analisa uma string de expressão usando variáveis locais disponíveis e a armazena
Impressora LaTeX	`print_latex_expression`	Imprime uma expressão armazenada em formato LaTeX, juntamente com as suposições das variáveis
Solver Algébrico	`solve_algebraically`	Resolve uma equação algebricamente para uma variável dada em um domínio dado
Solver Linear	`solve_linear_system`	Resolve um sistema de equações lineares
Solver Não Linear	`solve_nonlinear_system`	Resolve um sistema de equações não lineares
Variável de Função	`introduce_function`	Introduz uma variável de função para uso em equações diferenciais
Solver de EDO	`dsolve_ode`	Resolve uma equação diferencial ordinária
Solver de EDP	`pdsolve_pde`	Resolve uma equação diferencial parcial
Métrica Padrão	`create_predefined_metric`	Cria uma métrica de espaço-tempo predefinida (ex.: Schwarzschild, Kerr, Minkowski)
Busca de Métrica	`search_predefined_metrics`	Busca métricas predefinidas disponíveis
Calculadora de Tensores	`calculate_tensor`	Calcula tensores a partir de uma métrica (tensores de Ricci, Einstein, Weyl)
Métrica Personalizada	`create_custom_metric`	Cria um tensor métrico personalizado a partir de componentes e símbolos fornecidos
Tensor LaTeX	`print_latex_tensor`	Imprime uma expressão tensorial armazenada em formato LaTeX
Simplificador	`simplify_expression`	Simplifica uma expressão matemática usando a função de canonicalização do SymPy
Substituição	`substitute_expression`	Substitui uma variável por uma expressão em outra expressão
Integração	`integrate_expression`	Integra uma expressão em relação a uma variável
Diferenciação	`differentiate_expression`	Diferencia uma expressão em relação a uma variável
Coordenadas	`create_coordinate_system`	Cria um sistema de coordenadas 3D para operações de cálculo vetorial
Campo Vetorial	`create_vector_field`	Cria um campo vetorial no sistema de coordenadas especificado
Rotacional	`calculate_curl`	Calcula o rotacional de um campo vetorial
Divergência	`calculate_divergence`	Calcula a divergência de um campo vetorial
Gradiente	`calculate_gradient`	Calcula o gradiente de um campo escalar
Conversor de Unidades	`convert_to_units`	Converte uma quantidade para as unidades de destino fornecidas
Simplificador de Unidades	`quantity_simplify_units`	Simplifica uma quantidade com unidades
Criador de Matriz	`create_matrix`	Cria uma matriz SymPy a partir dos dados fornecidos
Determinante	`matrix_determinant`	Calcula o determinante de uma matriz
Inversa de Matriz	`matrix_inverse`	Calcula a inversa de uma matriz
Autovalores	`matrix_eigenvalues`	Calcula os autovalores de uma matriz
Autovetores	`matrix_eigenvectors`	Calcula os autovetores de uma matriz

Por padrão, as variáveis são predefinidas com suposições (semelhante a como a função symbols() funciona no SymPy). A menos que especificado de outra forma, a suposição padrão é que uma variável é complexa, comutativa, termo sobre o campo complexo $\mathbb{C}$.

Propriedade	Valor
`commutative`	true
`complex`	true
`finite`	true
`infinite`	false

Configuração do Claude Desktop

Normalmente, o comando mcp install adicionará automaticamente o servidor ao arquivo claude_desktop_config.json. Se não adicionar, você precisa encontrar o arquivo de configuração e adicionar o seguinte:

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

Adicione o seguinte ao objeto mcpServers, substituindo /ABSOLUTE_PATH_TO_SYMPY_MCP/server.py pelo caminho absoluto para o arquivo server.py do sympy-mcp.

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "/opt/homebrew/bin/uv",
      "args": [
        "run",
        "--with",
        "einsteinpy",
        "--with",
        "mcp[cli]",
        "--with",
        "pydantic",
        "--with",
        "sympy",
        "mcp",
        "run",
        "/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
      ]
    }
  }
}

Configuração do Cursor

No seu ~/.cursor/mcp.json, adicione o seguinte, onde ABSOLUTE_PATH_TO_SYMPY_MCP é o caminho para o arquivo server.py do sympy-mcp.

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "/opt/homebrew/bin/uv",
      "args": [
        "run",
        "--with",
        "einsteinpy",
        "--with",
        "mcp[cli]",
        "--with",
        "pydantic",
        "--with",
        "sympy",
        "mcp",
        "run",
        "/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
      ]
    }
  }
}

Configuração do VS Code

O VS Code e o VS Code Insiders agora suportam MCPs no modo agente. Para o VS Code, você pode precisar habilitar Chat > Agent: Enable nas configurações.

Configuração com um clique:

OU adicione manualmente a configuração ao seu settings.json (global):

{
  "mcp": {
    "servers": {
      "sympy-mcp": {
        "command": "uv",
        "args": [
          "run",
          "--with",
          "einsteinpy",
          "--with",
          "mcp[cli]",
          "--with",
          "pydantic",
          "--with",
          "sympy",
          "mcp",
          "run",
          "/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
        ]
      }
    }
  }
}

Clique em "Iniciar" acima da configuração do servidor, mude para o modo agente no chat, e tente comandos como "integre x^2" ou "resolva x^2 = 1" para começar.

Configuração do Cline

Para usar com Cline, você precisa executar manualmente o servidor MCP primeiro usando os comandos na seção "Uso". Uma vez que o servidor MCP esteja em execução, abra o Cline e selecione "Servidores MCP" no topo.

Então selecione "Servidores Remotos" e adicione o seguinte:

Nome do Servidor: sympy-mcp
URL do Servidor: http://127.0.0.1:8081/sse

Configuração do 5ire

Outro cliente MCP que suporta múltiplos modelos (o3, o4-mini, DeepSeek-R1, etc.) no backend é o 5ire.

Para configurar com 5ire, abra o 5ire e vá para Ferramentas -> Nova e defina as seguintes configurações:

Chave da Ferramenta: sympy-mcp
Nome: SymPy MCP
Comando: /opt/homebrew/bin/uv run --with einsteinpy --with mcp[cli] --with pydantic --with sympy mcp run /ABSOLUTE_PATH_TO/server.py

Substitua /ABSOLUTE_PATH_TO/server.py pelo caminho real para o arquivo server.py do seu sympy-mcp.

Transporte HTTP (HTTP Streamable / SSE)

O servidor suporta MCP sobre HTTP usando o transporte streamable-http introduzido na especificação MCP 2025-03-26. Isso substitui o transporte SSE legado e expõe um único endpoint /mcp ao qual os clientes se conectam via HTTP.

Este é o transporte recomendado ao executar o servidor como um processo autônomo ou em um contêiner, porque permite que qualquer cliente MCP com capacidade HTTP se conecte sem precisar iniciar o servidor como um subprocesso.

# Run locally with HTTP transport
uv run python server.py --transport streamable-http

# Override host/port
uv run python server.py --transport streamable-http --mcp-host 127.0.0.1 --mcp-port 9000

O sinalizador legado --transport sse ainda é suportado para compatibilidade retroativa.

Um endpoint /healthcheck também é exposto, que executa um ciclo completo do protocolo MCP (initialize → tools/list → encerramento da sessão) e retorna {"status": "ok", "tool_count": N}.

Executando em Contêiner

Você pode construir e executar o servidor usando Docker localmente:

# Build the Docker image
docker build -t sympy-mcp .

# Run the Docker container
docker run -p 8081:8081 sympy-mcp

Ou use Docker Compose a partir do diretório docker/:

cd docker
docker compose up -d --build

Alternativamente, você pode puxar a imagem pré-construída do GitHub Container Registry:

# Pull the latest image
docker pull ghcr.io/sdiehl/sympy-mcp:main

# Run the container
docker run -p 8081:8081 --rm ghcr.io/sdiehl/sympy-mcp:main

Para configurar o Claude Desktop para iniciar o contêiner Docker, edite seu arquivo claude_desktop_config.json:

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-p",
        "8081:8081",
        "--rm",
        "sympy-mcp"
      ]
    }
  }
}

Ou para usar o contêiner pré-construído do GitHub:

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-p",
        "8081:8081",
        "--rm",
        "ghcr.io/sdiehl/sympy-mcp:main"
      ]
    }
  }
}

Esta configuração diz ao Claude Desktop para iniciar o contêiner Docker quando necessário. Certifique-se de construir a imagem Docker (docker build -t sympy-mcp .) antes de usar o Claude Desktop com esta configuração.

Os outros métodos de instalação também podem ser adaptados para funcionar com Docker se você alterar o comando uv para usar o comando docker run.

Exemplo de Interação 1: Equações Diferenciais

Aqui está um exemplo de como a chamada de ferramentas funciona em uma conversa com um assistente de IA usando este servidor MCP:

Usuário: Resolva o oscilador harmônico amortecido com termo de forçamento: o sistema massa-mola-amortecedor descrito pela equação diferencial onde m é a massa, c é o coeficiente de amortecimento, k é a constante da mola, e F(t) é uma força externa.

$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$

Assistente: (Chamada de ferramenta interna) intro_many para introduzir variáveis:

{
  "variables": [
    {"var_name": "t", "pos_assumptions": ["real"], "neg_assumptions": []},
    {"var_name": "m", "pos_assumptions": ["real", "positive"], "neg_assumptions": []},
    {"var_name": "c", "pos_assumptions": ["real", "positive"], "neg_assumptions": []},
    {"var_name": "k", "pos_assumptions": ["real", "positive"], "neg_assumptions": []}
  ]
}

Assistente: (Chamada de ferramenta interna) introduce_function para definir x(t):

{
  "func_name": "x"
}

Assistente: (Chamada de ferramenta interna) introduce_expression para criar a equação diferencial:

{
  "expr_str": "Eq(m*Derivative(x(t), t, t) + c*Derivative(x(t), t) + k*x(t), F(t))"
}

Assistente: (Chamada de ferramenta interna) print_latex_expression para exibir a equação de forma elegante:

{
  "expr_key": "expr_12"
}

Resultado:

$$ c \frac{d}{d t} x{\left(t \right)} + k x{\left(t \right)} + m \frac{d^{2}}{d t^{2}} x{\left(t \right)} = F{\left(t \right)} $$

Assistente: (Chamada de ferramenta interna) introduce_function para definir F(t):

{
  "func_name": "F"
}

Assistente: (Chamada de ferramenta interna) dsolve_ode para resolver a equação diferencial:

{
  "expr_key": "expr_12",
  "func_name": "x"
}

Resultado:

$$ x{\left(t \right)} = C_{1} e^{\frac{t \left(- c + \sqrt{c^{2} - 4 k m}\right)}{2 m}} + C_{2} e^{- \frac{t \left(c + \sqrt{c^{2} - 4 k m}\right)}{2 m}} + \cdots $$

Exemplo de Interação 2: Relatividade Geral

Usuário: Calcule o traço do tensor de Ricci $R_{\mu\nu}$ usando a métrica inversa $g^{\mu\nu}$ para o espaço-tempo Anti-de Sitter para determinar sua curvatura escalar constante $R$.

Assistente: (Chamada de ferramenta interna) create_predefined_metric para criar a métrica Anti-de Sitter:

{
  "metric_name": "AntiDeSitter"
}

Assistente: (Chamada de ferramenta interna) calculate_tensor para calcular o tensor de Ricci:

{
  "metric_key": "metric_AntiDeSitter",
  "tensor_type": "RICCI_TENSOR",
  "simplify_result": true
}

Assistente: (Chamada de ferramenta interna) print_latex_tensor para exibir o tensor de Ricci:

{
  "tensor_key": "riccitensor_metric_AntiDeSitter"
}

Resultado:

$$ \left[\begin{matrix}3 & 0 & 0 & 0\\0 & - 3 \cos^{2}{\left(t \right)} & 0 & 0\\0 & 0 & - 3 \cos^{2}{\left(t \right)} \sinh^{2}{\left(\chi \right)} & 0\\0 & 0 & 0 & - 3 \sin^{2}{\left(\theta \right)} \cos^{2}{\left(t \right)} \sinh^{2}{\left(\chi \right)}\end{matrix}\right] $$

Assistente: (Chamada de ferramenta interna) calculate_tensor para calcular o escalar de Ricci:

{
  "metric_key": "metric_AntiDeSitter",
  "tensor_type": "RICCI_SCALAR",
  "simplify_result": true
}

Assistente: (Chamada de ferramenta interna) print_latex_tensor para exibir o escalar de Ricci:

{
  "tensor_key": "ricciscalar_metric_AntiDeSitter"
}

Resultado:

$$ -12 $$

Exemplo de Interação 3: Sistema de EDOs Acoplado (Dinâmica de Fluidos)

Este exemplo demonstra a resolução de um sistema acoplado de EDOs e a verificação da solução contra uma análise algébrica de estado estacionário — uma tarefa onde LLMs tipicamente alucinam sem um CAS para fundamentar cada etapa.

Usuário:

Use as ferramentas do sympy-mcp para resolver isto simbolicamente — não calcule à mão.

Dois tanques cilíndricos estão conectados por um cano. O Tanque 1 tem área de seção transversal A₁ = 2 m² e recebe um fluxo constante de entrada Q = 0,5 m³/s. A água drena do Tanque 1 para o Tanque 2 através de um cano com vazão proporcional à diferença de altura: q₁₂ = k·(h₁ - h₂) onde k = 0,3 m²/s. O Tanque 2 tem área de seção transversal A₂ = 1 m² e drena para o exterior a uma taxa q₂ = k·h₂ com o mesmo k.

Monte e resolva o sistema acoplado de EDOs para as alturas de água h₁(t) e h₂(t), partindo de tanques vazios (h₁(0) = 0, h₂(0) = 0). Em seguida, encontre as alturas em estado estacionário quando t → ∞ resolvendo as equações de equilíbrio algebricamente e verifique se elas correspondem à solução de longo prazo das EDOs.

Assistente: (Cadeia de ferramentas interna)

intro_many — introduzir t, k, A1, A2, Q com suposições reais/positivas
introduce_function × 2 — introduzir h1(t) e h2(t) como funções desconhecidas
introduce_expression × 2 — codificar as EDOs de balanço de massa:

$$A_1 \frac{dh_1}{dt} = Q - k(h_1 - h_2), \quad A_2 \frac{dh_2}{dt} = k(h_1 - h_2) - k h_2$$

substitute_expression — substituir valores numéricos para k, A1, A2, Q
dsolve_ode × 2 — resolver o sistema acoplado; aplicar condições iniciais via substitute_expression
introduce_expression × 2 — codificar equações de equilíbrio (derivadas definidas como zero)
solve_linear_system — resolver o sistema algébrico 2×2 para h1*, h2*
print_latex_expression — exibir tanto a solução no domínio do tempo quanto os valores de estado estacionário

Aviso de Segurança

Este servidor roda no seu computador e dá ao modelo de linguagem acesso para executar lógica Python. Notavelmente, ele usa o parse_expr do Sympy para analisar expressões matemáticas, que usa eval internamente, permitindo efetivamente execução arbitrária de código. Ao executar o servidor, você está confiando no código que o Claude gera. Executar na imagem Docker é um pouco mais seguro, mas ainda é uma boa ideia revisar o código antes de executá-lo.

Licença

Este projeto está licenciado sob a Licença Apache 2.0. Consulte o arquivo LICENSE para obter detalhes.