MCP-Typescribe - an MCP Server providing LLMs API information

by yWorks

46 stars

314 downloads

Not rated

GitHub

About

An MCP server implementation enabling LLMs to work with new APIs and frameworks

Details

Author: yWorks
GitHub stars: 46
Downloads: 314
Categories: Developer Tools, Knowledge Base, API, AI

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name MCP-Typescribe - an MCP Server providing LLMs API information

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

From the repository

You generate TypeDoc JSON for your TypeScript API, build the project with npm run build, then run the server using npx mcp-typescribe@latest run-server <path-to-api.json>. AI agents such as Cline in VS Code connect to the server by specifying it in their MCP settings (e.g., cline_mcp_settings.json). The server exposes tools like search_symbols and get_symbol_details for agents to query.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mcp-typescribe - an mcp server providing llms api information": {
            "mcp-typescribe": {
                "command": "npx",
                "args": [
                    "typedoc",
                    "--json",
                    "docs/api.json",
                    "--entryPointStrategy",
                    "expand",
                    "path/to/your/typescript/files"
                ]
            }
        }
    }
}

McpServers

{
    "mcp-typescribe": {
        "command": "npx",
        "args": [
            "typedoc",
            "--json",
            "docs/api.json",
            "--entryPointStrategy",
            "expand",
            "path/to/your/typescript/files"
        ]
    }
}

MCP-Typescribe - an MCP Server providing LLMs API information

Large Language Models (LLMs) have made incredible strides in code generation and developer productivity. However, they face a key limitation: they can only reliably use APIs and libraries they’ve seen during training. This creates a bottleneck for adopting new tools, SDKs, or internal APIs — LLMs simply don’t know how to use them effectively.

While tools can be given source code access (when interacting with APIs for which the sources are available) or access to documentation files (e.g. typescript type definition files), this doesn't scale well for large APIs. LLMs need a more efficient way to learn more about an API. Putting all the documentation into context for every request is inefficient, unfeasible, and leads to poor results.

Larger new or internal APIs remain "invisible" to LLMs.

Developers must manually guide LLMs or provide example usage.

Innovation is slowed by the lag between an API’s release and its widespread understanding by AI tools.

This project is an open-source implementation of the Model Context Protocol (MCP)—a protocol designed to provide LLMs with contextual, real-time access to information. In this case it's the API documentation, and particularly for now in this project TypeScript definitions.

Parse TypeScript (and other) definitions into a machine-readable format.

Serve this context dynamically to LLMs through tools like Claude, Cline, Cursor, or Windsurf and other custom interfaces.

Enable agentic behavior by letting LLMs query, plan, and adapt to unfamiliar APIs without retraining.

Plug-and-play API support for LLM-based coding assistants.

Faster onboarding for new or proprietary SDKs.

A step toward more autonomous, context-aware coding agents.

This project provides a way for AI agents to efficiently explore and understand unknown TypeScript APIs. It loads TypeDoc-generated JSON documentation and exposes it through a set of query endpoints that allow agents to search for symbols, get detailed information about specific parts of the API, and understand relationships between different components.

- TypeDoc Integration: Loads and indexes TypeDoc JSON documentation for efficient querying
- Comprehensive Query Capabilities: Provides a wide range of tools for exploring TypeScript APIs
- MCP Protocol: Follows the Model Context Protocol for seamless integration with AI agents

The server provides the following tools for querying the API:

- search_symbols: Find symbols by name with optional filtering by kind
- get_symbol_details: Get detailed information about a specific symbol
- list_members: List methods and properties of a class or interface
- get_parameter_info: Get information about function parameters
- find_implementations: Find implementations of interfaces or subclasses
- search_by_return_type: Find functions returning a specific type
- search_by_description: Search in JSDoc comments
- get_type_hierarchy: Show inheritance relationships
- find_usages: Find where a type/function is used
- Clone the repository
- Install dependencies:

npm install

Generate TypeDoc JSON for your TypeScript API:

npx typedoc --json docs/api.json --entryPointStrategy expand path/to/your/typescript/files

If you (only) have an existing.d.tsfile, you can create an api json file like so:

{ "extends": "./tsconfig.json", "files": ](https://www.yfiles.com/the-yfiles-sdk/web/yfiles-for-html/yfiles-mcp-server)["existing.d.ts"], "typedocOptions": { "entryPoints": ["existing.d.ts"], "json": "docs/api.json", "pretty": false } }

npx typedoc --tsconfig tsconfig.docs.json

npx @modelcontextprotocol/inspector node ./dist/mcp-server/cli.js run-server docs/api.json

Connect an AI agent to the server to query the API

E.g. with cline in VSCode, specify the following MCP server incline_mcp_settings.json:

{ "mcpServers": { "typescribe": { "command": "npx", "args": [ "-y", "mcp-typescribe@latest", "run-server", "<PATH_TO_API_DOT_JSON>" ], "env": {} } } }

Enable the server and likely auto-approve the various tools. Tell the agent to use the "typescribe" tool to learn about your API.

- src/sample-api/: A sample TypeScript API for testing - it uses a weird German-like dialect for the API names to test that the LLM does not hallucinate the API
- src/mcp-server/: The MCP server implementation

- utils/: Utility functions
- schemas/: JSON schemas for the MCP tools
- core/: Core functionality
- server.ts: The MCP server implementation
- index.ts: Entry point for the library exports
- cli.ts: the entry point for the CLI/binary

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

Local stdio MCP server that lets AI coding agents read and maintain structured architecture, rules, and decisions directly from your repository.

Official Context7 MCP server that brings up-to-date, version-specific library documentation and code examples into AI coding prompts.

Remote, no-auth MCP server providing AI-powered codebase context and answers

MCP server that ingests project docs once and lets Claude search by meaning instead of reading everything — saving tokens on large codebases

Easily provide codebase context to Large Language Models (LLMs).

Context7 Private Docs MCP is a paid hosted remote MCP for private, version-pinned documentation context, source citations, stale-doc checks, and usage receipts for coding agents.

An intelligent system for managing programming rules, supporting search, versioning, code validation, and prompt enhancement.

Search DevExpress documentation (300,000+ help topics) using natural language queries across Angular, Blazor, WPF, WinForms, ASP.NET Core, React, Vue, and more in the AI Coding Assistant and/or IDE of your choice. Receive instant code examples, implementation guidance, and step-by-step instructions. Built-in tools and prompts guide AI coding agents to help developers build better applications faster with DevExpress components.

The official Duck Framework MCP server provides AI assistants with rich, project-aware context for building applications using Duck Framework. It offers documentation retrieval, code guidance, API references, best practices, component discovery, and framework-specific recommendations to help developers generate high-quality Duck Framework projects faster and more accurately.

GeneXus 18 MCP server for Claude, Cursor, and AI agents — read, edit, analyze KB objects (transactions, web panels, procedures, SDTs) over the Model Context Protocol.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

MCP-Typescribe - an MCP Server providing LLMs API information

Install

More like this

Aws Kb Retrieval Server

Memory

Sentry

Github

Git

GitLab