anyapi-mcp-server 1.1.3 → 1.2.0

package/README.md

@@ -54,40 +54,70 @@ You can provide both `--spec` and `--base-url` together. If only `--spec` is giv
 
 Add to your MCP configuration (e.g. `~/.cursor/mcp.json` or Claude Desktop config):
 
+#### Cloudflare API
+
+```json
+{
+  "mcpServers": {
+    "cloudflare": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "anyapi-mcp-server",
+        "--name", "cloudflare",
+        "--spec", "/path/to/cloudflare-openapi.json",
+        "--base-url", "https://api.cloudflare.com/client/v4",
+        "--header", "Authorization: Bearer ${CLOUDFLARE_API_TOKEN}"
+      ],
+      "env": {
+        "CLOUDFLARE_API_TOKEN": "your-cloudflare-api-token"
+      }
+    }
+  }
+}
+```
+
+#### Datadog API
+
 ```json
 {
   "mcpServers": {
-    "petstore": {
+    "datadog": {
       "command": "npx",
       "args": [
         "-y",
         "anyapi-mcp-server",
-        "--name", "petstore",
-        "--spec", "/path/to/petstore.yaml",
-        "--base-url", "https://petstore.swagger.io/v2"
-      ]
+        "--name", "datadog",
+        "--spec", "/path/to/datadog-openapi.json",
+        "--base-url", "https://api.datadoghq.com/api/v1",
+        "--header", "DD-API-KEY: ${DD_API_KEY}",
+        "--header", "DD-APPLICATION-KEY: ${DD_APP_KEY}"
+      ],
+      "env": {
+        "DD_API_KEY": "your-datadog-api-key",
+        "DD_APP_KEY": "your-datadog-app-key"
+      }
     }
   }
 }
 ```
 
-With authentication headers:
+#### Metabase API
 
 ```json
 {
   "mcpServers": {
-    "my-api": {
+    "metabase": {
       "command": "npx",
       "args": [
         "-y",
         "anyapi-mcp-server",
-        "--name", "my-api",
-        "--spec", "/path/to/openapi.json",
-        "--base-url", "https://api.example.com",
-        "--header", "Authorization: Bearer ${API_TOKEN}"
+        "--name", "metabase",
+        "--base-url", "https://your-metabase-instance.com/api",
+        "--header", "x-api-key: ${METABASE_API_KEY}"
       ],
       "env": {
-        "API_TOKEN": "your-token-here"
+        "METABASE_API_KEY": "your-metabase-api-key"
       }
     }
   }

package/build/api-index.js

@@ -144,6 +144,22 @@ export class ApiIndex {
                     description: p.description,
                 }));
                 const requestBodySchema = extractRequestBodySchema(op.requestBody, rawSpec);
+                // Extract response descriptions
+                let responses;
+                if (op.responses) {
+                    responses = Object.entries(op.responses).map(([code, resp]) => ({
+                        statusCode: code,
+                        description: resp.description ?? "",
+                    }));
+                }
+                // Extract request body description
+                let requestBodyDescription;
+                if (op.requestBody && typeof op.requestBody === "object") {
+                    const rb = op.requestBody;
+                    if (typeof rb.description === "string") {
+                        requestBodyDescription = rb.description;
+                    }
+                }
                 const endpoint = {
                     method: method.toUpperCase(),
                     path,
@@ -153,6 +169,13 @@ export class ApiIndex {
                     parameters,
                     hasRequestBody: !!op.requestBody,
                     requestBodySchema,
+                    operationId: op.operationId,
+                    deprecated: op.deprecated ?? undefined,
+                    responses,
+                    requestBodyDescription,
+                    externalDocs: op.externalDocs?.url
+                        ? { url: op.externalDocs.url, description: op.externalDocs.description }
+                        : undefined,
                 };
                 this.addEndpoint(endpoint);
             }

package/build/index.js

@@ -13,7 +13,7 @@ initLogger(config.logPath ?? null);
 const apiIndex = new ApiIndex(config.spec);
 const server = new McpServer({
     name: config.name,
-    version: "1.1.3",
+    version: "1.2.0",
 });
 // --- Tool 1: list_api ---
 server.tool("list_api", `List available ${config.name} API endpoints. ` +
@@ -252,6 +252,159 @@ server.tool("query_api", `Fetch data from a ${config.name} API endpoint, returni
         };
     }
 });
+// --- Tool 4: explain_api ---
+server.tool("explain_api", `Get detailed documentation for a ${config.name} API endpoint from the spec. ` +
+    "Returns all available spec information — summary, description, parameters, " +
+    "request body schema, response codes, deprecation status — without making any HTTP request. " +
+    "Use list_api first to discover endpoints, then explain_api to understand them before calling.", {
+    method: z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .describe("HTTP method"),
+    path: z
+        .string()
+        .describe("API path template (e.g. '/api/card/{id}')"),
+}, async ({ method, path }) => {
+    try {
+        const endpoint = apiIndex.getEndpoint(method, path);
+        if (!endpoint) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: `Endpoint not found: ${method} ${path}`,
+                            hint: "Use list_api to discover available endpoints.",
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const result = {
+            method: endpoint.method,
+            path: endpoint.path,
+            summary: endpoint.summary,
+        };
+        if (endpoint.description) {
+            result.description = endpoint.description;
+        }
+        if (endpoint.operationId) {
+            result.operationId = endpoint.operationId;
+        }
+        if (endpoint.deprecated) {
+            result.deprecated = true;
+        }
+        result.tag = endpoint.tag;
+        if (endpoint.parameters.length > 0) {
+            result.parameters = endpoint.parameters.map((p) => ({
+                name: p.name,
+                in: p.in,
+                required: p.required,
+                ...(p.description ? { description: p.description } : {}),
+            }));
+        }
+        if (endpoint.hasRequestBody) {
+            const bodyInfo = {};
+            if (endpoint.requestBodyDescription) {
+                bodyInfo.description = endpoint.requestBodyDescription;
+            }
+            if (endpoint.requestBodySchema) {
+                bodyInfo.contentType = endpoint.requestBodySchema.contentType;
+                bodyInfo.properties = endpoint.requestBodySchema.properties;
+            }
+            result.requestBody = bodyInfo;
+        }
+        if (endpoint.responses && endpoint.responses.length > 0) {
+            result.responses = endpoint.responses;
+        }
+        if (endpoint.externalDocs) {
+            result.externalDocs = endpoint.externalDocs;
+        }
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify({ error: message }) },
+            ],
+            isError: true,
+        };
+    }
+});
+// --- Tool 5: batch_query ---
+server.tool("batch_query", `Fetch data from multiple ${config.name} API endpoints concurrently. ` +
+    "Each request in the batch follows the query_api flow — makes a real HTTP request " +
+    "and returns only the fields selected via GraphQL query. " +
+    "All requests execute in parallel; one failure does not affect the others. " +
+    "IMPORTANT: Run call_api first on each endpoint to discover schema field names.", {
+    requests: z
+        .array(z.object({
+        method: z
+            .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+            .describe("HTTP method"),
+        path: z.string().describe("API path template"),
+        params: z
+            .record(z.unknown())
+            .optional()
+            .describe("Path and query parameters"),
+        body: z
+            .record(z.unknown())
+            .optional()
+            .describe("Request body for POST/PUT/PATCH"),
+        query: z
+            .string()
+            .describe("GraphQL selection query (use field names from call_api schema)"),
+        headers: z
+            .record(z.string())
+            .optional()
+            .describe("Additional HTTP headers for this request"),
+    }))
+        .min(1)
+        .max(10)
+        .describe("Array of requests to execute concurrently (1-10)"),
+}, async ({ requests }) => {
+    try {
+        const settled = await Promise.allSettled(requests.map(async (req) => {
+            const rawData = await callApi(config, req.method, req.path, req.params, req.body, req.headers, "none");
+            const endpoint = apiIndex.getEndpoint(req.method, req.path);
+            const schema = getOrBuildSchema(rawData, req.method, req.path, endpoint?.requestBodySchema);
+            const queryResult = await executeQuery(schema, rawData, req.query);
+            return { method: req.method, path: req.path, data: queryResult };
+        }));
+        const results = settled.map((outcome, i) => {
+            if (outcome.status === "fulfilled") {
+                return outcome.value;
+            }
+            const message = outcome.reason instanceof Error
+                ? outcome.reason.message
+                : String(outcome.reason);
+            return {
+                method: requests[i].method,
+                path: requests[i].path,
+                error: message,
+            };
+        });
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(results, null, 2) },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify({ error: message }) },
+            ],
+            isError: true,
+        };
+    }
+});
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anyapi-mcp-server",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "A universal MCP server that connects any REST API (via OpenAPI spec) to AI assistants, with GraphQL-style field selection and automatic schema inference.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",