符号计算工具服务器

# Install and run locally
make install
make run-local

# Test with cmcp (in another terminal)
cmcp ".venv/bin/python -m src.main" tools/list

# Deploy to OpenShift
make deploy PROJECT=calculus-helper

d/dx(x^3 + 2*x)       -> 3*x**2 + 2
d^2/dx^2(x^4)          -> 12*x**2
d/dy(x*y^2)            -> 2*x*y
d/dx(sin(x)*cos(x))    -> cos(2*x)

integral(x^2, x)              -> x**3/3 + C
integral(sin(x), x, 0, pi)   -> 2

lim(sin(x)/x, x, 0)          -> 1
lim(1/x, x, 0, "+")          -> oo
lim(1/x, x, 0, "both")       -> ToolError: left = -oo, right = oo

series(exp(x), x, 0, 6)      -> 1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
series(sin(x), x, 0, 4)      -> x - x**3/6 + O(x**4)
series(exp(x), x, 1, 3)      -> E + E*(x-1) + E*(x-1)**2/2 + O((x-1)**3)

solve(x^2 - 4 = 0, x)        -> x = -2, 2
solve(3*x + 1 = 7, x)        -> x = 2
solve(x^2 - 1)               -> x = -1, 1   (assumes = 0)
solve(x + y = 5, x)          -> x = 5 - y

ode(y' - 2*y = 0)                          -> y(x) = C1*exp(2*x)
ode(y'' + y = 0, ics="y(0)=1, y'(0)=0")    -> y(x) = cos(x)

partial_derivative(x*y^2, vars="x,y", wrt="y")   -> 2*x*y
gradient(x^2+y^2+z^2, vars="x,y,z")              -> [2*x, 2*y, 2*z]
divergence([2*x, 2*y, 2*z], vars="x,y,z")        -> 6
curl([-y, x, 0], vars="x,y,z")                   -> [0, 0, 2]
double_integral(x*y, vars="x,y", bounds="x:0,1; y:0,1")  -> 1/4

src/
  core/           # Server bootstrap, dynamic loading, auth, logging
  tools/          # Calculus tool implementations
    _sympy_helpers.py   # Shared expression parsing and formatting
  resources/      # calculus://reference/{topic} resource
  prompts/        # calculus_tutor prompt
  middleware/     # (none currently)
tests/
  tools/          # Tool unit tests
  resources/      # Resource tests
  prompts/        # Prompt tests
Containerfile     # Container definition (UBI base)
openshift.yaml    # OpenShift manifests
deploy.sh         # Deployment script
Makefile          # Common tasks

from typing import Annotated
from pydantic import Field
from fastmcp import Context
from fastmcp.exceptions import ToolError
from src.core.app import mcp

@mcp.tool(
    annotations={"readOnlyHint": True, "idempotentHint": True, "openWorldHint": False}
)
async def my_tool(
    expression: Annotated[str, Field(description="Math expression")],
    ctx: Context = None,
) -> str:
    """Tool description for the LLM."""
    # Use helpers from src.tools._sympy_helpers for parsing/formatting
    return "result"

from src.core.app import mcp

@mcp.resource("calculus://my-resource/{param}")
async def my_resource(param: str) -> str:
    """Resource description."""
    return "content"

from pydantic import Field
from src.core.app import mcp

@mcp.prompt
def my_prompt(
    topic: str = Field(description="Topic area"),
) -> str:
    """Prompt purpose."""
    return f"You are an expert in {topic}..."

from src.core.app import mcp            # correct
from src.tools._sympy_helpers import parse_expression  # correct
from core.app import mcp                # WRONG - causes dual FastMCP instances

# Run all tests
make test

# Or directly
.venv/bin/pytest tests/ -v

# Run a single test file
.venv/bin/pytest tests/tools/test_compute_derivative.py -v

# Run tests matching a pattern
.venv/bin/pytest tests/ -k "test_limit" -v

# Test with cmcp (STDIO, requires separate terminal)
make test-local
cmcp ".venv/bin/python -m src.main" tools/call compute_derivative '{"expression": "x^3", "variable": "x"}'

from src.tools.compute_derivative import compute_derivative

@pytest.mark.asyncio
async def test_power_rule():
    result = await compute_derivative.fn(expression="x^3", variable="x")
    assert "3*x**2" in result