How to Set Up Model Context Protocol Server for Internal Pac

Building internal tools that bridge AI assistants with your package registry documentation requires a solid integration strategy. The Model Context Protocol (MCP) provides a standardized way for AI models to interact with external services, making it an ideal choice for creating a documentation server that your AI coding assistants can query directly. This guide walks you through setting up an MCP server specifically designed for internal package registry documentation.

Understanding the Model Context Protocol

The Model Context Protocol defines how AI assistants communicate with external tools and data sources. Rather than hardcoding integrations for each AI provider, MCP offers an unified interface that works across different AI platforms. Your internal package registry documentation becomes accessible through a consistent API that any MCP-compatible AI assistant can use.

An MCP server acts as a bridge between the AI and your internal systems. When a developer asks an AI assistant about a specific package, version requirements, or API documentation, the MCP server retrieves that information from your documentation sources and returns it in a format the AI can process.

Prerequisites and Initial Setup

Before building your MCP server, ensure you have Node.js version 18 or higher installed. You’ll also need a package registry that exposes documentation through an API or static files. Most internal registries using Verdaccio, Nexus, or JFrog already provide the necessary endpoints.

Create a new project directory and initialize it:

mkdir mcp-registry-docs && cd mcp-registry-docs
npm init -y
npm install @modelcontextprotocol/sdk typescript @types/node

The SDK provides the core classes needed to implement an MCP server. TypeScript ensures type safety throughout your implementation.

Creating the MCP Server Implementation

Create a file named src/server.ts with the following implementation:

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

interface PackageDoc {
  name: string;
  version: string;
  description: string;
  readme: string;
  dependencies: Record<string, string>;
}

// Simulated documentation cache - replace with actual registry API calls
const docsCache = new Map<string, PackageDoc>();

async function fetchPackageDoc(packageName: string): Promise<PackageDoc | null> {
  // Replace with your actual registry endpoint
  const response = await fetch(`https://your-registry.internal/api/packages/${packageName}`);
  if (!response.ok) return null;
  return response.json();
}

const server = new Server(
  {
    name: 'internal-registry-docs',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: 'get_package_docs',
        description: 'Retrieve documentation for a specific package',
        inputSchema: {
          type: 'object',
          properties: {
            packageName: { type: 'string', description: 'Name of the package' },
            version: { type: 'string', description: 'Specific version (optional)' },
          },
          required: ['packageName'],
        },
      },
      {
        name: 'search_packages',
        description: 'Search packages in the internal registry',
        inputSchema: {
          type: 'object',
          properties: {
            query: { type: 'string', description: 'Search query' },
          },
          required: ['query'],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'get_package_docs') {
    const pkg = await fetchPackageDoc(args.packageName);
    if (!pkg) {
      return { content: [{ type: 'text', text: `Package ${args.packageName} not found` }] };
    }
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(pkg, null, 2),
        },
      ],
    };
  }

  if (name === 'search_packages') {
    // Implement search logic against your registry
    const results = Array.from(docsCache.entries())
      .filter(([key]) => key.includes(args.query))
      .map(([key, val]) => ({ name: key, version: val.version }));
    return { content: [{ type: 'text', text: JSON.stringify(results) }] };
  }

  throw new Error(`Unknown tool: ${name}`);
});

const transport = new StdioServerTransport();
await server.connect(transport);

This server exposes two tools that AI assistants can call: get_package_docs retrieves documentation for a specific package, and search_packages allows searching across your registry.

Configuring Your AI Assistant

After implementing the server, you need to configure your AI assistant to use it. Most MCP-compatible assistants use a configuration file to specify available servers:

{
  "mcpServers": {
    "registry-docs": {
      "command": "node",
      "args": ["/path/to/mcp-registry-docs/dist/server.js"],
      "env": {
        "REGISTRY_URL": "https://your-registry.internal"
      }
    }
  }
}

The exact configuration varies depending on your AI assistant. Claude Code, Cursor, and other popular assistants each have their own configuration format. Consult your assistant’s documentation for the specific syntax required.

Connecting to Your Internal Registry

The implementation above uses a placeholder fetch call. For production use, replace the fetchPackageDoc function with actual calls to your registry’s API. Most package registries expose endpoints like /api/packages/{name} or support npm registry compatibility at /{packageName}.

If your documentation lives in a separate system such as a Git repository or static site, you can modify the server to fetch from those sources instead:

async function fetchPackageDoc(packageName: string): Promise<PackageDoc> {
  // Fetch from your internal doc system
  const docResponse = await fetch(
    `https://docs.internal.company.com/packages/${packageName}/metadata.json`
  );
  const readmeResponse = await fetch(
    `https://docs.internal.company.com/packages/${packageName}/readme.md`
  );

  return {
    ...await docResponse.json(),
    readme: await readmeResponse.text()
  };
}

This flexibility allows your MCP server to aggregate documentation from multiple sources, creating an unified interface for AI assistants.

Testing Your Implementation

Test the server manually before connecting it to an AI assistant:

npm run build
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | node dist/server.js

For more testing, use the MCP Inspector tool:

npx @modelcontextprotocol/inspector node dist/server.js

The inspector provides an UI for testing each tool your server exposes and verifying that responses match expected formats.

Deployment Considerations

When deploying your MCP server to production, consider the following: run the server as a local process that the AI assistant starts on demand, use environment variables for sensitive configuration like registry authentication tokens, implement caching to reduce latency and registry load, and monitor usage to understand which packages developers query most frequently.

You can containerize the server for easier deployment:

FROM node:20-slim
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist/ ./dist/
CMD ["node", "dist/server.js"]

Build and run with docker build -t mcp-registry-docs. followed by docker run mcp-registry-docs.

Built by theluckystrike — More at zovo.one