Server Prompts

from mcp_use import MCPServer

server = MCPServer(name="my-server")

@server.prompt(
    name="greeting",
    description="Generate a friendly greeting"
)
async def greeting(name: str) -> str:
    """Generate a personalized greeting"""
    return f"Hello, {name}! How can I assist you today?"

from typing import Annotated
from pydantic import Field

@server.prompt(
    name="code_review",
    title="Code Review Assistant",
    description="Generate a code review prompt for any programming language"
)
async def code_review(
    language: Annotated[str, Field(description="Programming language")],
    code: Annotated[str, Field(description="Code to review")]
) -> str:
    """Generate a code review prompt"""
    return f"""
Please review the following {language} code:

```{language}
{code}

## Documentation Prompt

```python
@server.prompt(
    name="write_docs",
    title="Documentation Generator",
    description="Generate documentation for a function or class"
)
async def write_docs(
    code_type: Annotated[str, Field(description="Type: function, class, or module")],
    code: Annotated[str, Field(description="Code to document")],
    style: Annotated[str, Field(description="Doc style: google, numpy, or sphinx", default="google")]
) -> str:
    """Generate documentation for code"""
    return f"""
Generate {style}-style documentation for the following {code_type}:

```python
{code}

## Task Planning Prompt

```python
@server.prompt(
    name="plan_task",
    title="Task Planner",
    description="Break down complex tasks into steps"
)
async def plan_task(
    task: Annotated[str, Field(description="Task to plan")],
    context: Annotated[str, Field(description="Additional context", default="")]
) -> str:
    """Generate a task planning prompt"""
    base_prompt = f"""
Break down the following task into clear, actionable steps:

Task: {task}
"""
    
    if context:
        base_prompt += f"\nContext: {context}"
    
    base_prompt += """

For each step:
1. Describe what needs to be done
2. List any prerequisites
3. Identify potential challenges
4. Suggest tools or resources needed
"""
    
    return base_prompt

import json

@server.prompt(
    name="analyze_data",
    title="Data Analysis Assistant",
    description="Generate prompts for data analysis tasks"
)
async def analyze_data(
    data_description: Annotated[str, Field(description="Description of the data")],
    questions: Annotated[list[str], Field(description="Questions to answer")]
) -> str:
    """Generate a data analysis prompt"""
    questions_text = "\n".join(f"{i+1}. {q}" for i, q in enumerate(questions))
    
    return f"""
Analyze the following data: {data_description}

Answer these questions:
{questions_text}

For each question:
- Provide the answer with supporting data
- Show your methodology
- Highlight any interesting patterns
- Suggest follow-up questions
"""

@server.prompt(
    name="debug_code",
    title="Debug Assistant",
    description="Help debug code issues"
)
async def debug_code(
    language: Annotated[str, Field(description="Programming language")],
    code: Annotated[str, Field(description="Code with issues")],
    error: Annotated[str, Field(description="Error message or description")]
) -> str:
    """Generate a debugging prompt"""
    return f"""
Help debug this {language} code:

```{language}
{code}

{error}

## System Design Prompt

```python
@server.prompt(
    name="design_system",
    title="System Design Assistant",
    description="Generate system design prompts"
)
async def design_system(
    system_type: Annotated[str, Field(description="Type of system to design")],
    requirements: Annotated[list[str], Field(description="System requirements")],
    scale: Annotated[str, Field(description="Expected scale", default="medium")]
) -> str:
    """Generate a system design prompt"""
    req_text = "\n".join(f"- {req}" for req in requirements)
    
    return f"""
Design a {system_type} with the following requirements:

{req_text}

Expected scale: {scale}

Provide:
1. High-level architecture diagram (describe components)
2. Technology stack recommendations
3. Data flow and storage strategy
4. Scalability considerations
5. Security measures
6. Monitoring and observability approach
"""

from mcp.server.fastmcp import Context

@server.prompt(
    name="session_info",
    description="Provide session context information"
)
async def session_info(context: Context) -> str:
    """Generate a prompt with session information"""
    session = context.request_context.session
    return f"""
You are in an active MCP session.
Session ID: {getattr(session, 'session_id', 'unknown')}

You have access to the following capabilities:
- Tools: {len(context.fastmcp._mcp_server.list_tools())}
- Resources: {len(context.fastmcp._mcp_server.list_resources())}
- Prompts: {len(context.fastmcp._mcp_server.list_prompts())}

How can I help you?
"""

@server.prompt(
    name="translate",
    title="Translation Assistant",
    description="Generate translation prompts"
)
async def translate(
    text: Annotated[str, Field(description="Text to translate")],
    source_lang: Annotated[str, Field(description="Source language")],
    target_lang: Annotated[str, Field(description="Target language")],
    style: Annotated[str, Field(description="Translation style", default="formal")]
) -> str:
    """Generate a translation prompt"""
    return f"""
Translate the following text from {source_lang} to {target_lang}:

"{text}"

Style: {style}

Provide:
1. The translated text
2. Alternative translations if appropriate
3. Cultural notes or context
4. Explanation of any translation choices
"""