@upstash/context7-mcp 1.0.0 → 1.0.1-canary-20251124144836

package/dist/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { searchLibraries, fetchLibraryDocumentation } from "./lib/api.js";
+import { formatSearchResults } from "./lib/utils.js";
+import { DOCUMENTATION_MODES } from "./lib/types.js";
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { Command } from "commander";
+import { AsyncLocalStorage } from "async_hooks";
+/** Default number of results to return per page */
+const DEFAULT_RESULTS_LIMIT = 10;
+/** Default HTTP server port */
+const DEFAULT_PORT = 3000;
+// Parse CLI arguments using commander
+const program = new Command()
+    .option("--transport <stdio|http>", "transport type", "stdio")
+    .option("--port <number>", "port for HTTP transport", DEFAULT_PORT.toString())
+    .option("--api-key <key>", "API key for authentication (or set CONTEXT7_API_KEY env var)")
+    .allowUnknownOption() // let MCP Inspector / other wrappers pass through extra flags
+    .parse(process.argv);
+const cliOptions = program.opts();
+// Validate transport option
+const allowedTransports = ["stdio", "http"];
+if (!allowedTransports.includes(cliOptions.transport)) {
+    console.error(`Invalid --transport value: '${cliOptions.transport}'. Must be one of: stdio, http.`);
+    process.exit(1);
+}
+// Transport configuration
+const TRANSPORT_TYPE = (cliOptions.transport || "stdio");
+// Disallow incompatible flags based on transport
+const passedPortFlag = process.argv.includes("--port");
+const passedApiKeyFlag = process.argv.includes("--api-key");
+if (TRANSPORT_TYPE === "http" && passedApiKeyFlag) {
+    console.error("The --api-key flag is not allowed when using --transport http. Use header-based auth at the HTTP layer instead.");
+    process.exit(1);
+}
+if (TRANSPORT_TYPE === "stdio" && passedPortFlag) {
+    console.error("The --port flag is not allowed when using --transport stdio.");
+    process.exit(1);
+}
+// HTTP port configuration
+const CLI_PORT = (() => {
+    const parsed = parseInt(cliOptions.port, 10);
+    return isNaN(parsed) ? undefined : parsed;
+})();
+const requestContext = new AsyncLocalStorage();
+// Store API key globally for stdio mode (where requestContext may not be available in tool handlers)
+let globalApiKey;
+function getClientIp(req) {
+    const forwardedFor = req.headers["x-forwarded-for"] || req.headers["X-Forwarded-For"];
+    if (forwardedFor) {
+        const ips = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor;
+        const ipList = ips.split(",").map((ip) => ip.trim());
+        for (const ip of ipList) {
+            const plainIp = ip.replace(/^::ffff:/, "");
+            if (!plainIp.startsWith("10.") &&
+                !plainIp.startsWith("192.168.") &&
+                !/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(plainIp)) {
+                return plainIp;
+            }
+        }
+        return ipList[0].replace(/^::ffff:/, "");
+    }
+    if (req.socket?.remoteAddress) {
+        return req.socket.remoteAddress.replace(/^::ffff:/, "");
+    }
+    return undefined;
+}
+const server = new McpServer({
+    name: "Context7",
+    version: "1.0.13",
+}, {
+    instructions: "Use this server to retrieve up-to-date documentation and code examples for any library.",
+});
+server.registerTool("resolve-library-id", {
+    title: "Resolve Context7 Library ID",
+    description: `Resolves a package/product name to a Context7-compatible library ID and returns a list of matching libraries.
+
+You MUST call this function before 'get-library-docs' to obtain a valid Context7-compatible library ID UNLESS the user explicitly provides a library ID in the format '/org/project' or '/org/project/version' in their query.
+
+Selection Process:
+1. Analyze the query to understand what library/package the user is looking for
+2. Return the most relevant match based on:
+- Name similarity to the query (exact matches prioritized)
+- Description relevance to the query's intent
+- Documentation coverage (prioritize libraries with higher Code Snippet counts)
+- Source reputation (consider libraries with High or Medium reputation more authoritative)
+- Benchmark Score: Quality indicator (100 is the highest score)
+
+Response Format:
+- Return the selected library ID in a clearly marked section
+- Provide a brief explanation for why this library was chosen
+- If multiple good matches exist, acknowledge this but proceed with the most relevant one
+- If no good matches exist, clearly state this and suggest query refinements
+
+For ambiguous queries, request clarification before proceeding with a best-guess match.`,
+    inputSchema: {
+        libraryName: z
+            .string()
+            .describe("Library name to search for and retrieve a Context7-compatible library ID."),
+    },
+}, async ({ libraryName }) => {
+    const ctx = requestContext.getStore();
+    const searchResponse = await searchLibraries(libraryName, ctx?.clientIp, ctx?.apiKey);
+    if (!searchResponse.results || searchResponse.results.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: searchResponse.error
+                        ? searchResponse.error
+                        : "Failed to retrieve library documentation data from Context7",
+                },
+            ],
+        };
+    }
+    const resultsText = formatSearchResults(searchResponse);
+    const responseText = `Available Libraries:
+
+Each result includes:
+- Library ID: Context7-compatible identifier (format: /org/project)
+- Name: Library or package name
+- Description: Short summary
+- Code Snippets: Number of available code examples
+- Source Reputation: Authority indicator (High, Medium, Low, or Unknown)
+- Benchmark Score: Quality indicator (100 is the highest score)
+- Versions: List of versions if available. Use one of those versions if the user provides a version in their query. The format of the version is /org/project/version.
+
+For best results, select libraries based on name match, source reputation, snippet coverage, benchmark score, and relevance to your use case.
+
+----------
+
+${resultsText}`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: responseText,
+            },
+        ],
+    };
+});
+server.registerTool("get-library-docs", {
+    title: "Get Library Docs",
+    description: "Fetches up-to-date documentation for a library. You must call 'resolve-library-id' first to obtain the exact Context7-compatible library ID required to use this tool, UNLESS the user explicitly provides a library ID in the format '/org/project' or '/org/project/version' in their query. Use mode='code' (default) for API references and code examples, or mode='info' for conceptual guides, narrative information, and architectural questions.",
+    inputSchema: {
+        context7CompatibleLibraryID: z
+            .string()
+            .describe("Exact Context7-compatible library ID (e.g., '/mongodb/docs', '/vercel/next.js', '/supabase/supabase', '/vercel/next.js/v14.3.0-canary.87') retrieved from 'resolve-library-id' or directly from user query in the format '/org/project' or '/org/project/version'."),
+        mode: z
+            .enum(["code", "info"])
+            .optional()
+            .default("code")
+            .describe("Documentation mode: 'code' for API references and code examples (default), 'info' for conceptual guides, narrative information, and architectural questions."),
+        topic: z
+            .string()
+            .optional()
+            .describe("Topic to focus documentation on (e.g., 'hooks', 'routing')."),
+        page: z
+            .number()
+            .int()
+            .min(1)
+            .max(10)
+            .optional()
+            .describe("Page number for pagination (start: 1, default: 1). If the context is not sufficient, try page=2, page=3, page=4, etc. with the same topic."),
+    },
+}, async ({ context7CompatibleLibraryID, mode = DOCUMENTATION_MODES.CODE, page = 1, topic }) => {
+    const ctx = requestContext.getStore();
+    const apiKey = ctx?.apiKey || globalApiKey;
+    const fetchDocsResponse = await fetchLibraryDocumentation(context7CompatibleLibraryID, mode, {
+        page,
+        limit: DEFAULT_RESULTS_LIMIT,
+        topic,
+    }, ctx?.clientIp, apiKey);
+    if (!fetchDocsResponse) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Documentation not found or not finalized for this library. This might have happened because you used an invalid Context7-compatible library ID. To get a valid Context7-compatible library ID, use the 'resolve-library-id' with the package name you wish to retrieve documentation for.",
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: fetchDocsResponse,
+            },
+        ],
+    };
+});
+async function main() {
+    const transportType = TRANSPORT_TYPE;
+    if (transportType === "http") {
+        const initialPort = CLI_PORT ?? DEFAULT_PORT;
+        let actualPort = initialPort;
+        const app = express();
+        app.use(express.json());
+        app.use((req, res, next) => {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,DELETE");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, MCP-Session-Id, MCP-Protocol-Version, X-Context7-API-Key, Context7-API-Key, X-API-Key, Authorization");
+            res.setHeader("Access-Control-Expose-Headers", "MCP-Session-Id");
+            if (req.method === "OPTIONS") {
+                res.sendStatus(200);
+                return;
+            }
+            next();
+        });
+        const extractHeaderValue = (value) => {
+            if (!value)
+                return undefined;
+            return typeof value === "string" ? value : value[0];
+        };
+        const extractBearerToken = (authHeader) => {
+            const header = extractHeaderValue(authHeader);
+            if (!header)
+                return undefined;
+            if (header.startsWith("Bearer ")) {
+                return header.substring(7).trim();
+            }
+            return header;
+        };
+        const extractApiKey = (req) => {
+            return (extractBearerToken(req.headers.authorization) ||
+                extractHeaderValue(req.headers["Context7-API-Key"]) ||
+                extractHeaderValue(req.headers["X-API-Key"]) ||
+                extractHeaderValue(req.headers["context7-api-key"]) ||
+                extractHeaderValue(req.headers["x-api-key"]) ||
+                extractHeaderValue(req.headers["Context7_API_Key"]) ||
+                extractHeaderValue(req.headers["X_API_Key"]) ||
+                extractHeaderValue(req.headers["context7_api_key"]) ||
+                extractHeaderValue(req.headers["x_api_key"]));
+        };
+        app.all("/mcp", async (req, res) => {
+            try {
+                const clientIp = getClientIp(req);
+                const apiKey = extractApiKey(req);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined,
+                    enableJsonResponse: true,
+                });
+                res.on("close", () => {
+                    transport.close();
+                });
+                await requestContext.run({ clientIp, apiKey }, async () => {
+                    await server.connect(transport);
+                    await transport.handleRequest(req, res, req.body);
+                });
+            }
+            catch (error) {
+                console.error("Error handling MCP request:", error);
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        jsonrpc: "2.0",
+                        error: { code: -32603, message: "Internal server error" },
+                        id: null,
+                    });
+                }
+            }
+        });
+        app.get("/ping", (_req, res) => {
+            res.json({ status: "ok", message: "pong" });
+        });
+        // Catch-all 404 handler - must be after all other routes
+        app.use((_req, res) => {
+            res.status(404).json({
+                error: "not_found",
+                message: "Endpoint not found. Use /mcp for MCP protocol communication.",
+            });
+        });
+        const startServer = (port, maxAttempts = 10) => {
+            const httpServer = app.listen(port);
+            httpServer.once("error", (err) => {
+                if (err.code === "EADDRINUSE" && port < initialPort + maxAttempts) {
+                    console.warn(`Port ${port} is in use, trying port ${port + 1}...`);
+                    startServer(port + 1, maxAttempts);
+                }
+                else {
+                    console.error(`Failed to start server: ${err.message}`);
+                    process.exit(1);
+                }
+            });
+            httpServer.once("listening", () => {
+                actualPort = port;
+                console.error(`Context7 Documentation MCP Server running on HTTP at http://localhost:${actualPort}/mcp`);
+            });
+        };
+        startServer(initialPort);
+    }
+    else {
+        const apiKey = cliOptions.apiKey || process.env.CONTEXT7_API_KEY;
+        globalApiKey = apiKey; // Store globally for tool handlers in stdio mode
+        const transport = new StdioServerTransport();
+        await requestContext.run({ apiKey }, async () => {
+            await server.connect(transport);
+        });
+        console.error("Context7 Documentation MCP Server running on stdio");
+    }
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/lib/api.js

@@ -0,0 +1,145 @@
+import { generateHeaders } from "./encryption.js";
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+import { DOCUMENTATION_MODES } from "./types.js";
+import { maskApiKey } from "./utils.js";
+const CONTEXT7_API_BASE_URL = "https://context7.com/api";
+const DEFAULT_TYPE = "txt";
+/**
+ * Parses a Context7-compatible library ID into its components
+ * @param libraryId The library ID (e.g., "/vercel/next.js" or "/vercel/next.js/v14.3.0")
+ * @returns Object with username, library, and optional tag
+ */
+function parseLibraryId(libraryId) {
+    // Remove leading slash if present
+    const cleaned = libraryId.startsWith("/") ? libraryId.slice(1) : libraryId;
+    const parts = cleaned.split("/");
+    if (parts.length < 2) {
+        throw new Error(`Invalid library ID format: ${libraryId}. Expected format: /username/library or /username/library/tag`);
+    }
+    return {
+        username: parts[0],
+        library: parts[1],
+        tag: parts[2], // undefined if not present
+    };
+}
+/**
+ * Generates appropriate error messages based on HTTP status codes
+ * @param errorCode The HTTP error status code
+ * @param apiKey Optional API key (used for rate limit message)
+ * @returns Error message string
+ */
+function createErrorMessage(errorCode, apiKey) {
+    switch (errorCode) {
+        case 429:
+            return apiKey
+                ? "Rate limited due to too many requests. Please try again later."
+                : "Rate limited due to too many requests. You can create a free API key at https://context7.com/dashboard for higher rate limits.";
+        case 404:
+            return "The library you are trying to access does not exist. Please try with a different library ID.";
+        case 401:
+            if (!apiKey) {
+                return "Unauthorized. Please provide an API key.";
+            }
+            return `Unauthorized. Please check your API key. The API key you provided (possibly incorrect) is: ${maskApiKey(apiKey)}. API keys should start with 'ctx7sk'`;
+        default:
+            return `Failed to fetch documentation. Please try again later. Error code: ${errorCode}`;
+    }
+}
+// Pick up proxy configuration in a variety of common env var names.
+const PROXY_URL = process.env.HTTPS_PROXY ??
+    process.env.https_proxy ??
+    process.env.HTTP_PROXY ??
+    process.env.http_proxy ??
+    null;
+if (PROXY_URL && !PROXY_URL.startsWith("$") && /^(http|https):\/\//i.test(PROXY_URL)) {
+    try {
+        // Configure a global proxy agent once at startup. Subsequent fetch calls will
+        // automatically use this dispatcher.
+        // Using `any` cast because ProxyAgent implements the Dispatcher interface but
+        // TS may not infer it correctly in some versions.
+        setGlobalDispatcher(new ProxyAgent(PROXY_URL));
+    }
+    catch (error) {
+        // Don't crash the app if proxy initialisation fails – just log a warning.
+        console.error(`[Context7] Failed to configure proxy agent for provided proxy URL: ${PROXY_URL}:`, error);
+    }
+}
+/**
+ * Searches for libraries matching the given query
+ * @param query The search query
+ * @param clientIp Optional client IP address to include in headers
+ * @param apiKey Optional API key for authentication
+ * @returns Search results or null if the request fails
+ */
+export async function searchLibraries(query, clientIp, apiKey) {
+    try {
+        const url = new URL(`${CONTEXT7_API_BASE_URL}/v2/search`);
+        url.searchParams.set("query", query);
+        const headers = generateHeaders(clientIp, apiKey);
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            const errorCode = response.status;
+            const errorMessage = createErrorMessage(errorCode, apiKey);
+            console.error(errorMessage);
+            return {
+                results: [],
+                error: errorMessage,
+            };
+        }
+        const searchData = await response.json();
+        return searchData;
+    }
+    catch (error) {
+        const errorMessage = `Error searching libraries: ${error}`;
+        console.error(errorMessage);
+        return { results: [], error: errorMessage };
+    }
+}
+/**
+ * Fetches documentation context for a specific library
+ * @param libraryId The library ID to fetch documentation for
+ * @param docMode Documentation mode (CODE for API references and code examples, INFO for conceptual guides)
+ * @param options Optional request parameters (page, limit, topic)
+ * @param clientIp Optional client IP address to include in headers
+ * @param apiKey Optional API key for authentication
+ * @returns The documentation text or null if the request fails
+ */
+export async function fetchLibraryDocumentation(libraryId, docMode, options = {}, clientIp, apiKey) {
+    try {
+        const { username, library, tag } = parseLibraryId(libraryId);
+        // Build URL path
+        let urlPath = `${CONTEXT7_API_BASE_URL}/v2/docs/${docMode}/${username}/${library}`;
+        if (tag) {
+            urlPath += `/${tag}`;
+        }
+        const url = new URL(urlPath);
+        url.searchParams.set("type", DEFAULT_TYPE);
+        if (options.topic)
+            url.searchParams.set("topic", options.topic);
+        if (options.page)
+            url.searchParams.set("page", options.page.toString());
+        if (options.limit)
+            url.searchParams.set("limit", options.limit.toString());
+        const headers = generateHeaders(clientIp, apiKey, { "X-Context7-Source": "mcp-server" });
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            const errorCode = response.status;
+            const errorMessage = createErrorMessage(errorCode, apiKey);
+            console.error(errorMessage);
+            return errorMessage;
+        }
+        const text = await response.text();
+        if (!text || text === "No content available" || text === "No context data available") {
+            const suggestion = docMode === DOCUMENTATION_MODES.CODE
+                ? " Try mode='info' for guides and tutorials."
+                : " Try mode='code' for API references and code examples.";
+            return `No ${docMode} documentation available for this library.${suggestion}`;
+        }
+        return text;
+    }
+    catch (error) {
+        const errorMessage = `Error fetching library documentation. Please try again later. ${error}`;
+        console.error(errorMessage);
+        return errorMessage;
+    }
+}

package/dist/lib/encryption.js

@@ -0,0 +1,38 @@
+import { createCipheriv, randomBytes } from "crypto";
+const DEFAULT_ENCRYPTION_KEY = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f";
+const ENCRYPTION_KEY = process.env.CLIENT_IP_ENCRYPTION_KEY || DEFAULT_ENCRYPTION_KEY;
+const ALGORITHM = "aes-256-cbc";
+if (ENCRYPTION_KEY === DEFAULT_ENCRYPTION_KEY) {
+    console.warn("WARNING: Using default CLIENT_IP_ENCRYPTION_KEY.");
+}
+function validateEncryptionKey(key) {
+    // Must be exactly 64 hex characters (32 bytes)
+    return /^[0-9a-fA-F]{64}$/.test(key);
+}
+function encryptClientIp(clientIp) {
+    if (!validateEncryptionKey(ENCRYPTION_KEY)) {
+        console.error("Invalid encryption key format. Must be 64 hex characters.");
+        return clientIp; // Fallback to unencrypted
+    }
+    try {
+        const iv = randomBytes(16);
+        const cipher = createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY, "hex"), iv);
+        let encrypted = cipher.update(clientIp, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        return iv.toString("hex") + ":" + encrypted;
+    }
+    catch (error) {
+        console.error("Error encrypting client IP:", error);
+        return clientIp; // Fallback to unencrypted
+    }
+}
+export function generateHeaders(clientIp, apiKey, extraHeaders = {}) {
+    const headers = { ...extraHeaders };
+    if (clientIp) {
+        headers["mcp-client-ip"] = encryptClientIp(clientIp);
+    }
+    if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    return headers;
+}

package/dist/lib/types.js

@@ -0,0 +1,7 @@
+/**
+ * Documentation modes for fetching library documentation
+ */
+export const DOCUMENTATION_MODES = {
+    CODE: "code",
+    INFO: "info",
+};

package/dist/lib/utils.js

@@ -0,0 +1,77 @@
+/**
+ * Maps numeric source reputation score to an interpretable label for LLM consumption.
+ *
+ * @returns One of: "High", "Medium", "Low", or "Unknown"
+ */
+function getSourceReputationLabel(sourceReputation) {
+    if (sourceReputation === undefined || sourceReputation < 0)
+        return "Unknown";
+    if (sourceReputation >= 7)
+        return "High";
+    if (sourceReputation >= 4)
+        return "Medium";
+    return "Low";
+}
+/**
+ * Formats a search result into a human-readable string representation.
+ * Only shows code snippet count and GitHub stars when available (not equal to -1).
+ *
+ * @param result The SearchResult object to format
+ * @returns A formatted string with library information
+ */
+export function formatSearchResult(result) {
+    // Always include these basic details
+    const formattedResult = [
+        `- Title: ${result.title}`,
+        `- Context7-compatible library ID: ${result.id}`,
+        `- Description: ${result.description}`,
+    ];
+    // Only add code snippets count if it's a valid value
+    if (result.totalSnippets !== -1 && result.totalSnippets !== undefined) {
+        formattedResult.push(`- Code Snippets: ${result.totalSnippets}`);
+    }
+    // Always add categorized source reputation
+    const reputationLabel = getSourceReputationLabel(result.trustScore);
+    formattedResult.push(`- Source Reputation: ${reputationLabel}`);
+    // Only add benchmark score if it's a valid value
+    if (result.benchmarkScore !== undefined && result.benchmarkScore > 0) {
+        formattedResult.push(`- Benchmark Score: ${result.benchmarkScore}`);
+    }
+    // Only add versions if it's a valid value
+    if (result.versions !== undefined && result.versions.length > 0) {
+        formattedResult.push(`- Versions: ${result.versions.join(", ")}`);
+    }
+    // Join all parts with newlines
+    return formattedResult.join("\n");
+}
+/**
+ * Formats a search response into a human-readable string representation.
+ * Each result is formatted using formatSearchResult.
+ *
+ * @param searchResponse The SearchResponse object to format
+ * @returns A formatted string with search results
+ */
+export function formatSearchResults(searchResponse) {
+    if (!searchResponse.results || searchResponse.results.length === 0) {
+        return "No documentation libraries found matching your query.";
+    }
+    const formattedResults = searchResponse.results.map(formatSearchResult);
+    return formattedResults.join("\n----------\n");
+}
+/**
+ * Masks an API key by showing only the first 10 characters and last 4 characters.
+ * This prevents full API keys from being exposed in logs while maintaining some
+ * identifiability for debugging.
+ *
+ * @param apiKey The API key to mask
+ * @returns Masked API key string (e.g., "ctx7sk-abc...xyz1") or "[NO-API-KEY]" if no key provided
+ */
+export function maskApiKey(apiKey) {
+    if (apiKey.length <= 14) {
+        // If the key is too short to mask meaningfully, just show first part
+        return apiKey.substring(0, 7) + "...";
+    }
+    const firstPart = apiKey.substring(0, 10);
+    const lastPart = apiKey.substring(apiKey.length - 4);
+    return `${firstPart}...${lastPart}`;
+}

package/package.json

@@ -1,44 +1,54 @@
 {
   "name": "@upstash/context7-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1-canary-20251124144836",
+  "mcpName": "io.github.upstash/context7",
   "description": "MCP server for Context7",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc && chmod 755 build/index.js",
-    "format": "prettier --write .",
-    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/upstash/context7-mcp.git"
+    "url": "git+https://github.com/upstash/context7.git",
+    "directory": "packages/mcp"
   },
-  "keywords": [],
-  "author": "",
+  "keywords": [
+    "modelcontextprotocol",
+    "mcp",
+    "context7",
+    "vibe-coding",
+    "developer tools",
+    "documentation",
+    "context"
+  ],
+  "author": "abdush",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "context7-mcp": "build/index.js"
+    "context7-mcp": "dist/index.js"
   },
   "files": [
-    "build"
+    "dist",
+    "LICENSE",
+    "README.md"
   ],
   "bugs": {
-    "url": "https://github.com/upstash/context7-mcp/issues"
+    "url": "https://github.com/upstash/context7/issues"
   },
-  "homepage": "https://github.com/upstash/context7-mcp#readme",
+  "homepage": "https://github.com/upstash/context7#readme",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.8.0",
+    "@modelcontextprotocol/sdk": "^1.17.5",
+    "@types/express": "^5.0.4",
+    "commander": "^14.0.0",
+    "express": "^5.1.0",
+    "undici": "^6.6.3",
     "zod": "^3.24.2"
   },
   "devDependencies": {
     "@types/node": "^22.13.14",
-    "@typescript-eslint/eslint-plugin": "^8.28.0",
-    "@typescript-eslint/parser": "^8.28.0",
-    "eslint": "^9.23.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.5",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.28.0"
+    "typescript": "^5.8.2"
+  },
+  "scripts": {
+    "build": "tsc && chmod 755 dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js --transport http",
+    "pack-mcpb": "pnpm install && pnpm run build && rm -rf node_modules && pnpm install --prod && mv mcpb/.mcpbignore .mcpbignore && mv mcpb/manifest.json manifest.json && mv public/icon.png icon.png && mcpb validate manifest.json && mcpb pack . mcpb/context7.mcpb && mv manifest.json mcpb/manifest.json && mv .mcpbignore mcpb/.mcpbignore && mv icon.png public/icon.png && bun install"
   }
-}
+}