Demo Prompts in MCP Servers

{
  "id": "greeting",
  "title": "Personalized Greeting",
  "description": "Creates a greeting using the user's name.",
  "template": "Hello, {{name}}! Welcome to our MCP prompt demo.",
  "variables": [
    { "name": "name", "description": "The recipient's name" }
  ]
}

{
  "id": "explain-concept",
  "title": "Concept Explainer",
  "description": "Explains complex concepts in simple terms.",
  "template": "Please explain {{concept}} in simple terms that a {{audience}} could understand. Use examples and analogies where appropriate.",
  "variables": [
    { "name": "concept", "description": "The concept to be explained" },
    { "name": "audience", "description": "The target audience (e.g., 'beginner', '10-year-old', 'college student')" }
  ]
}

{
  "id": "code-review",
  "title": "Code Review",
  "description": "Reviews code and suggests improvements.",
  "template": "Please review the following JavaScript code and provide suggestions for improvement:\n\n```javascript\n{{code}}\n```\n\nPlease focus on:\n- Code quality and best practices\n- Performance optimizations\n- Security considerations\n- Readability and maintainability",
  "variables": [
    { "name": "code", "description": "The JavaScript code to review" }
  ]
}

npm init -y
npm install @modelcontextprotocol/sdk zod node-fetch

#!/usr/bin/env node

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import fetch from 'node-fetch';

const OLLAMA_BASE_URL = 'http://localhost:11434';
const DEFAULT_MODEL = 'llama3.2:3b';

// Send the prompt text to Ollama's /api/generate endpoint and return the text response.
async function sendToOllama(prompt, model = DEFAULT_MODEL) {
  try {
    const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ model, prompt, stream: false })
    });
    const result = await response.json();

    // Ollama response formats can vary; prefer common fields or fallback to stringifying the result.
    return result.response ?? result?.generations?.[0]?.text ?? JSON.stringify(result);
  } catch (error) {
    return `Error: ${error.message}`;
  }
}

async function main() {
  const server = new McpServer({
    name: 'fixed-ollama-server',
    version: '1.0.0'
  });

  // Register "greeting" prompt
  server.registerPrompt(
    'greeting',
    {
      title: 'Personalized Greeting',
      description: 'Creates a personalized greeting'
    },
    // handler receives optional parameters when clients invoke this prompt
    async (params = {}) => {
      const name = params.name ?? 'Alice';
      const promptText = `Hello, ${name}! Welcome to our MCP prompt demo.`;
      const responseText = await sendToOllama(promptText);
      return {
        messages: [
          { role: 'user', content: { type: 'text', text: promptText } },
          { role: 'assistant', content: { type: 'text', text: responseText } }
        ]
      };
    }
  );

  // Register "explain-concept" prompt
  server.registerPrompt(
    'explain-concept',
    {
      title: 'Concept Explainer',
      description: 'Explains complex concepts simply'
    },
    async (params = {}) => {
      const concept = params.concept ?? 'quantum computing';
      const audience = params.audience ?? 'beginner';
      const promptText = `Please explain ${concept} in simple terms that a ${audience} could understand. Use examples and analogies where appropriate.`;
      const responseText = await sendToOllama(promptText);
      return {
        messages: [
          { role: 'user', content: { type: 'text', text: promptText } },
          { role: 'assistant', content: { type: 'text', text: responseText } }
        ]
      };
    }
  );

  // Register "code-review" prompt
  server.registerPrompt(
    'code-review',
    {
      title: 'Code Review',
      description: 'Provides suggestions for improving code'
    },
    async (params = {}) => {
      const code = params.code ?? 'function hello() { console.log("hi") }';
      const promptText = [
        'Please review the following javascript code and provide suggestions for improvement:',
        '```javascript',
        code,
        '```',
        '',
        'Please focus on:',
        '- Code quality and best practices',
        '- Performance optimizations',
        '- Security considerations',
        '- Readability and maintainability'
      ].join('\n');
      const responseText = await sendToOllama(promptText);
      return {
        messages: [
          { role: 'user', content: { type: 'text', text: promptText } },
          { role: 'assistant', content: { type: 'text', text: responseText } }
        ]
      };
    }
  );

  // Start the STDIO transport so the MCP server can communicate via stdin/stdout
  const transport = new StdioServerTransport();
  try {
    await server.connect(transport);
    console.log('All prompts registered\nServer ready');
    // Keep the process running to service incoming MCP requests over stdio.
  } catch (err) {
    console.error('Server error', err);
    process.exit(1);
  }
}

main().catch((err) => {
  console.error('Fatal error', err);
  process.exit(1);
});

npx @modelcontextprotocol/inspector node server.js

Starting MCP inspector...
🔑 Proxy server listening on localhost:6277
🔑 Session token: <token>
Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth
All prompts registered
Server ready

#!/usr/bin/env node

import { spawn } from 'child_process';

console.log('=== MCP Ollama Demo ===\nTesting multiple prompts with Ollama integration...\n');

async function startServer() {
  const serverProcess = spawn('node', ['server.js'], {
    cwd: process.cwd(),
    stdio: ['pipe', 'pipe', 'inherit']
  });

  return new Promise((resolve, reject) => {
    serverProcess.stdout.setEncoding('utf8');

    serverProcess.stdout.on('data', (chunk) => {
      const output = chunk.toString();
      process.stdout.write(output);

      if (output.includes('Server ready')) {
        resolve(serverProcess);
      }
    });

    serverProcess.on('error', (err) => reject(err));
    serverProcess.on('exit', (code) => {
      if (code !== 0) {
        reject(new Error(`Server exited with code ${code}`));
      }
    });
  });
}

(async () => {
  try {
    const serverProcess = await startServer();
    console.log('✓ Server initialized');

    // At this point you can use the MCP Inspector or an MCP client to call prompts.
    // This harness intentionally leaves actual MCP calls out to avoid duplicating
    // a full JSON-RPC-over-stdio implementation here.

    // Cleanup: stop the server after a short delay (for demo purposes)
    setTimeout(() => {
      serverProcess.kill();
      console.log('\n=== Demo completed ===');
    }, 3000);
  } catch (err) {
    console.error('Demo error:', err);
  }
})();

✅ All prompts registered
Server ready
✓ Server initialized
→ Sending prompt to Ollama...
✔ Got response from Ollama

RENDERED PROMPT:
Hello, Alice! Welcome to our MCP prompt demo.

OLLAMA RESPONSE:
*awkward smile* Oh, hi there... I'm not really sure what's going on or who you are, but I suppose I'll play along. What kind of demo is this? Is it some sort of... alternate history simulation? *nervous laugh*