// prisma/schema.prisma
 
generator client {
  provider = "prisma-client-js"
}
 
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
 
model Contact {
  id        String   @id @default(cuid())
  name      String
  email     String   @unique
  phone     String?
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

# .env
DATABASE_URL="postgresql://USER:PASSWORD@HOST:5432/contacts_db?sslmode=require"

// lib/prisma.ts
 
import { PrismaClient } from "@prisma/client";
 
const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};
 
export const prisma =
  globalForPrisma.prisma ??
  new PrismaClient({
    log: process.env.NODE_ENV === "development" ? ["query"] : [],
  });
 
if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;

# .env
DATABASE_URL="postgresql://..."
 
# Generate a strong key: openssl rand -hex 32
MCP_API_KEY="your-super-secret-api-key-here"

openssl rand -hex 32

mkdir -p app/api/\[transport\]
touch "app/api/[transport]/route.ts"

// app/api/[transport]/route.ts
 
import { createMcpHandler, withMcpAuth } from "mcp-handler";
import type { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
import { z } from "zod";
import { prisma } from "@/lib/prisma";
 
// ─── 1. Define the MCP Handler with all tools ────────────────────────────────
 
const handler = createMcpHandler(
  (server) => {
    // ── Tool 1: List All Contacts ──────────────────────────────────────────
    server.tool(
      "list_contacts",
      "Returns a list of all contacts stored in the database.",
      {}, // No input parameters needed
      async () => {
        const contacts = await prisma.contact.findMany({
          orderBy: { createdAt: "desc" },
        });
 
        if (contacts.length === 0) {
          return {
            content: [
              {
                type: "text",
                text: "No contacts found.",
              },
            ],
          };
        }
 
        const formatted = contacts
          .map(
            (c) => `• ${c.name} | ${c.email}${c.phone ? ` | ${c.phone}` : ""}`
          )
          .join("\n");
 
        return {
          content: [
            {
              type: "text",
              text: `Found ${contacts.length} contact(s):\n\n${formatted}`,
            },
          ],
        };
      }
    );
 
    // ── Tool 2: Create a Contact ───────────────────────────────────────────
    server.tool(
      "create_contact",
      "Creates a new contact in the database. Email must be unique.",
      {
        name: z.string().min(1, "Name is required"),
        email: z.string().email("Must be a valid email address"),
        phone: z.string().optional(),
      },
      async ({ name, email, phone }) => {
        // Check if a contact with this email already exists
        const existing = await prisma.contact.findUnique({
          where: { email },
        });
 
        if (existing) {
          return {
            content: [
              {
                type: "text",
                text: `❌ A contact with email "${email}" already exists.`,
              },
            ],
          };
        }
 
        const contact = await prisma.contact.create({
          data: { name, email, phone },
        });
 
        return {
          content: [
            {
              type: "text",
              text: `✅ Contact created successfully!\nName: ${contact.name}\nEmail: ${contact.email}${contact.phone ? `\nPhone: ${contact.phone}` : ""}\nID: ${contact.id}`,
            },
          ],
        };
      }
    );
 
    // ── Tool 3: Delete a Contact by Email ─────────────────────────────────
    server.tool(
      "delete_contact",
      "Deletes a contact from the database by their email address.",
      {
        email: z.string().email("Must be a valid email address"),
      },
      async ({ email }) => {
        const existing = await prisma.contact.findUnique({
          where: { email },
        });
 
        if (!existing) {
          return {
            content: [
              {
                type: "text",
                text: `❌ No contact found with email "${email}".`,
              },
            ],
          };
        }
 
        await prisma.contact.delete({
          where: { email },
        });
 
        return {
          content: [
            {
              type: "text",
              text: `🗑️ Contact "${existing.name}" (${email}) has been deleted successfully.`,
            },
          ],
        };
      }
    );
  },
  {}, // Server options (leave empty for defaults)
  {
    basePath: "/api", // Must match where [transport] is located
    maxDuration: 60, // 60 seconds max per request
    verboseLogs: process.env.NODE_ENV === "development",
  }
);
 
// ─── 2. Wrap the handler with API Key authentication ─────────────────────────
 
const authenticatedHandler = withMcpAuth(
  handler,
  async (request: Request, bearer: string | undefined): Promise<AuthInfo> => {
    // Reject requests with no token
    if (!bearer) {
      throw new Error(
        "Unauthorized: No API key provided. Pass your key as a Bearer token."
      );
    }
 
    // Compare the provided token with our secret key
    const validKey = process.env.MCP_API_KEY;
 
    if (!validKey) {
      throw new Error("Server misconfiguration: MCP_API_KEY is not set.");
    }
 
    if (bearer !== validKey) {
      throw new Error("Unauthorized: Invalid API key.");
    }
 
    // Return AuthInfo — you can attach extra metadata here
    return {
      token: bearer,
      clientId: "api-key-client",
      scopes: ["contacts:read", "contacts:write"],
    };
  }
);
 
// ─── 3. Export the handler for GET and POST HTTP methods ─────────────────────
 
export { authenticatedHandler as GET, authenticatedHandler as POST };

// prisma/seed.ts
 
import { PrismaClient } from "@prisma/client";
 
const prisma = new PrismaClient();
 
async function main() {
  await prisma.contact.createMany({
    data: [
      {
        name: "Alice Martin",
        email: "alice@example.com",
        phone: "+1-555-0101",
      },
      { name: "Bob Johnson", email: "bob@example.com", phone: "+1-555-0102" },
      { name: "Carol White", email: "carol@example.com" },
    ],
    skipDuplicates: true,
  });
 
  console.log("✅ Seed data inserted!");
}
 
main()
  .catch(console.error)
  .finally(() => prisma.$disconnect());

{
  "prisma": {
    "seed": "ts-node --compiler-options '{\"module\":\"CommonJS\"}' prisma/seed.ts"
  }
}

# This should return 401 Unauthorized
curl -X POST http://localhost:3000/api/mcp
 
# This should work — replace YOUR_KEY with the value in your .env
curl -X POST http://localhost:3000/api/mcp \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json"

{
  "mcpServers": {
    "contacts-local": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:3000/api/mcp",
        "--header",
        "Authorization: Bearer YOUR_KEY"
      ]
    }
  }
}

git init
git add .
git commit -m "feat: contacts MCP server"
gh repo create contacts-mcp --public --push
# Or use the GitHub website to create and push manually

# Basic syntax
claude mcp add --transport http <name> <url>
 
# Real example: Connect to Notion
claude mcp add --transport http notion https://mcp.notion.com/mcp
 
# Example with Bearer token
claude mcp add --transport http secure-api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"
 

{
  "mcpServers": {
    "contacts": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://contacts-mcp.vercel.app/api/mcp",
        "--header",
        "Authorization: Bearer YOUR_PRODUCTION_KEY"
      ]
    }
  }
}

{
  "mcpServers": {
    "contacts": {
      "url": "https://contacts-mcp.vercel.app/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_PRODUCTION_KEY"
      }
    }
  }
}

server.tool(
  "search_contacts",
  "Searches for contacts by name (case-insensitive).",
  {
    query: z.string().min(1, "Search query is required"),
  },
  async ({ query }) => {
    const contacts = await prisma.contact.findMany({
      where: {
        name: { contains: query, mode: "insensitive" },
      },
    });
 
    if (contacts.length === 0) {
      return {
        content: [
          { type: "text", text: `No contacts found matching "${query}".` },
        ],
      };
    }
 
    const formatted = contacts
      .map((c) => `• ${c.name} | ${c.email}`)
      .join("\n");
 
    return {
      content: [
        { type: "text", text: `Results for "${query}":\n\n${formatted}` },
      ],
    };
  }
);