Building a Legal Monitoring Agent

{
  "mcpServers": {
    "docketlayer": {
      "command": "npx",
      "args": ["-y", "@docketlayer/mcp-server"],
      "env": {
        "DOCKETLAYER_WALLET_PRIVATE_KEY": "your_base58_private_key",
        "DOCKETLAYER_DEFAULT_CONTEXT": "full"
      }
    }
  }
}

You are a legal monitoring assistant. Check each of the following cases for
new docket activity since the date shown. For any case that has new filings,
summarize what was filed, who filed it, and any deadlines or hearings set.

Cases to check:
- Court: nysd, Case: 1:24-cv-09822, Last checked: 2025-02-01T00:00:00-05:00
- Court: cacd, Case: 2:23-cv-04501, Last checked: 2025-02-01T08:00:00-08:00
- Court: ilnd, Case: 1:24-cv-01123, Last checked: 2025-02-01T00:00:00-06:00

Use docketlayer_case_query with last_checked set to the date shown for each case.
If a case shows no new activity, note that briefly and move on.

import anthropic, httpx, json
from datetime import datetime, timezone

client = anthropic.Anthropic()

# Tools definition for the Anthropic API
tools = [
    {
        "name": "query_case",
        "description": "Query a court case for current context and recent docket activity.",
        "input_schema": {
            "type": "object",
            "properties": {
                "court_code": {"type": "string"},
                "case_id":    {"type": "string"},
                "last_checked": {"type": "string", "description": "ISO-8601 timestamp"},
            },
            "required": ["court_code", "case_id", "last_checked"],
        },
    },
]

def handle_tool_call(tool_name: str, tool_input: dict) -> str:
    """Execute a tool call and return the result as a string."""
    if tool_name == "query_case":
        result = call_docketlayer(
            tool_input["court_code"],
            tool_input["case_id"],
            tool_input.get("last_checked"),
        )
        return json.dumps(result)
    raise ValueError(f"Unknown tool: {tool_name}")

def call_docketlayer(court_code: str, case_id: str, last_checked: str = None) -> dict:
    """Call GET /v2/case with x402 payment."""
    # build_payment_tx from "How x402 Works" guide
    params = {"court_code": court_code, "case_id": case_id}
    if last_checked:
        params["last_checked"] = last_checked

    probe = httpx.get("https://api.docketlayer.ai/v2/case", params=params)
    requirements = json.loads(probe.headers["X-Payment-Requirements"])
    encoded = build_payment_tx(solana_client, payer, requirements["payTo"],
                               int(requirements["maxAmountRequired"]) / 1e6)
    resp = httpx.get("https://api.docketlayer.ai/v2/case", params=params,
                     headers={"x402-payment": encoded})
    resp.raise_for_status()
    return resp.json()

def run_monitoring_agent(cases: list[dict], system_prompt: str) -> str:
    """Run an agentic loop that monitors the given cases."""
    user_message = "Check the following cases for new activity: " + json.dumps(cases)

    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=4096,
            system=system_prompt,
            tools=tools,
            messages=messages,
        )

        if response.stop_reason == "end_turn":
            # Extract the final text response
            return next(b.text for b in response.content if b.type == "text")

        # Process tool calls
        messages.append({"role": "assistant", "content": response.content})
        tool_results = []

        for block in response.content:
            if block.type == "tool_use":
                result = handle_tool_call(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result,
                })

        messages.append({"role": "user", "content": tool_results})