AI-Assisted Development¶

# src/my_server/tools/summarizer.py
from fastmcp import FastMCP
import httpx

mcp = FastMCP("summarizer")

@mcp.tool(description="Summarize text using an LLM")
async def summarize_text(text: str, max_length: int = 100) -> str:
    """
    Generate a concise summary of the provided text.

    Args:
        text: The text to summarize
        max_length: Maximum length of summary in characters

    Returns:
        A summarized version of the input text
    """
    if not text.strip():
        raise ValueError("Text cannot be empty")

    if max_length < 10:
        raise ValueError("max_length must be at least 10 characters")

    # Call OpenAI or local LLM
    async with httpx.AsyncClient() as client:
        response = await client.post(
            "http://localhost:11434/api/generate",  # Ollama
            json={
                "model": "granite4:3b",
                "prompt": f"Summarize this in {max_length} chars:\n\n{text}",
                "stream": False
            },
            timeout=30.0
        )
        response.raise_for_status()
        return response.json()["response"][:max_length]

# tests/test_summarizer.py
import pytest
from my_server.tools.summarizer import summarize_text

@pytest.mark.asyncio
async def test_summarize_text():
    """Test text summarization."""
    text = "This is a long text that needs to be summarized. " * 10
    summary = await summarize_text(text, max_length=50)

    assert len(summary) <= 50
    assert summary  # Not empty

@pytest.mark.asyncio
async def test_empty_text_raises_error():
    """Test that empty text raises ValueError."""
    with pytest.raises(ValueError, match="cannot be empty"):
        await summarize_text("", max_length=100)

# Type this comment:
# Create a tool that validates email addresses using regex

# Copilot suggests:
@mcp.tool(description="Validate email format")
def validate_email(email: str) -> bool:
    """Check if email has valid format."""
    import re
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    return re.match(pattern, email) is not None

# In test file, type:
# Test the validate_email function

# Copilot suggests:
def test_validate_email_valid():
    assert validate_email("test@example.com") == True
    assert validate_email("user.name@company.co.uk") == True

def test_validate_email_invalid():
    assert validate_email("invalid") == False
    assert validate_email("@example.com") == False
    assert validate_email("user@") == False

import asyncio
import httpx

async def fetch_with_retry(url: str, max_retries: int = 3) -> dict:
    """Fetch URL with exponential backoff retry."""
    for attempt in range(max_retries):
        try:
            async with httpx.AsyncClient() as client:
                response = await client.get(url, timeout=10.0)
                response.raise_for_status()
                return response.json()
        except (httpx.HTTPError, httpx.TimeoutException) as e:
            if attempt == max_retries - 1:
                raise
            delay = 2 ** attempt  # 1s, 2s, 4s
            await asyncio.sleep(delay)

# tests/test_with_ollama.py
import pytest
import httpx
import json
from my_server.server import mcp
from fastmcp.testing import create_test_client

@pytest.mark.asyncio
async def test_tool_with_llm():
    """Test MCP tool using Ollama + Granite 4."""

    # Start MCP server
    async with create_test_client(mcp) as mcp_client:
        # Get available tools
        tools = await mcp_client.list_tools()

        # Format tools for LLM
        tool_descriptions = [
            f"{t.name}: {t.description}"
            for t in tools
        ]

        # Ask Ollama to use a tool
        async with httpx.AsyncClient() as client:
            response = await client.post(
                "http://localhost:11434/api/generate",
                json={
                    "model": "granite4:3b",
                    "prompt": f"""
Available tools:
{chr(10).join(tool_descriptions)}

Task: Calculate the sum of 42 and 58.

Which tool should you call and with what parameters?
Respond in JSON format: {{"tool": "tool_name", "params": {{}}}}
                    """,
                    "stream": False,
                    "format": "json"
                }
            )

            llm_response = response.json()["response"]
            action = json.loads(llm_response)

            # Execute the tool the LLM selected
            result = await mcp_client.call_tool(
                action["tool"],
                action["params"]
            )

            assert "100" in result.content[0].text

# Error output:
# pydantic_core._pydantic_core.ValidationError: 1 validation error for ToolInput
# field required (type=value_error.missing)

# .git/hooks/pre-commit
#!/bin/bash

# Get changed Python files
CHANGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '\.py$')

if [ -z "$CHANGED_FILES" ]; then
    exit 0
fi

# Use LLM to review
for FILE in $CHANGED_FILES; do
    echo "Reviewing $FILE..."

    # Send to Claude Code or Continue
    REVIEW=$(llm "Review this code for:
    - Security issues
    - Error handling
    - Type safety
    - MCP best practices

    $(cat $FILE)")

    echo "$REVIEW"
done