Cortex: Convert API Specs into Docs, SDKs, and MCP Servers in One Click

One of the most tedious parts of API development is all the repetitive work that surrounds the actual interface: writing documentation, generating client SDKs, maintaining multiple language versions — and now, building an additional callable layer for AI agents on top of all that. The open-source project Cortex aims to unify these steps by treating the API spec as a single source of truth and automatically deriving docs, SDKs, and an MCP server from it.

The project topped Product Hunt's daily rankings with 151 upvotes and 26 comments, spanning the API, open source, developer tools, and GitHub categories. It was built by Nick Chisiu.

What Cortex Actually Does

Cortex positions itself as an "API knowledge layer." Its core logic is straightforward: accept mainstream API spec formats, then generate usable artifacts from those specs in multiple directions.

The supported input formats are comprehensive, covering REST, event-driven, query-based, and RPC paradigms:

• OpenAPI: The most widely used standard for describing REST APIs
• AsyncAPI: Designed for event-driven and message queue interfaces
• GraphQL: Schema descriptions for query-based APIs
• gRPC: High-performance remote procedure call protocol
• OpenRPC: Spec format for JSON-RPC interfaces

Bringing all five spec types under one toolchain means teams can use the same workflow to generate supporting assets regardless of their communication architecture — no need to find separate tools for each protocol.

OpenAPI (formerly Swagger) is the most widely used standard for describing REST APIs, defining paths, request parameters, response structures, and authentication in JSON or YAML format — the de facto industry standard. AsyncAPI is its counterpart for event-driven architectures (e.g., Kafka, WebSocket, MQTT), describing producer and consumer message contracts. GraphQL schemas define a queryable graph of data types, fundamentally different from REST's endpoint-by-endpoint approach. gRPC uses Protocol Buffers (.proto files) as its interface description language, emphasizing strong typing and high performance. OpenRPC is a spec format designed specifically for JSON-RPC 2.0 interfaces, commonly seen in blockchain node APIs and similar contexts. Together, these five formats cover the major paradigms of modern backend communication — unifying them in a single toolchain is unusually broad coverage for the industry.

Three Outputs: Docs, SDKs, and MCP Servers

The three categories of artifacts Cortex derives from a spec map directly onto the three most labor-intensive phases of the API lifecycle.

Interactive Documentation

The first output is interactive documentation. API docs often fall out of sync with the actual interface — code gets updated, documentation doesn't. Generating docs automatically from the spec as the source of truth goes a long way toward keeping documentation consistent with the interface and reducing drift caused by manual maintenance.

Typed SDKs in 11 Languages

The second output is typed SDKs across 11 programming languages. "Typed" is the key word here: the generated clients come with explicit type definitions, so callers get parameter hints and error checking at compile time or in their editor — rather than discovering problems at runtime. For API providers who need to publish clients across multiple language ecosystems, manually writing and maintaining 11 sets of SDKs is a significant cost. Auto-generation can substantially reduce that burden.

The difference between "typed SDKs" and untyped alternatives has real engineering consequences. Untyped clients (like raw HTTP requests or Python's requests library) have no parameter constraints — misspelled field names or wrong types only surface as runtime errors. Typed SDKs use a language's native type system (TypeScript interfaces, Python dataclasses/pydantic, Java POJOs, etc.) to codify the API's request and response structures, allowing IDEs to suggest available fields in real time and flag type mismatches while writing code. For API providers, there's another hidden benefit: once the spec file is updated, regenerating the SDKs syncs all language versions simultaneously, avoiding the feature divergence that creeps in when maintaining them by hand.

MCP Servers for AI Agents

The third output is the most distinctly of-the-moment feature — generating MCP servers for AI agents. MCP (Model Context Protocol) is a protocol for standardizing how large language models connect to external tools and data sources. When an API can automatically produce a corresponding MCP server, AI agents can use that interface directly as a callable tool, without developers needing to build an additional adaptation layer by hand.

This is what sets Cortex apart from traditional API code generators like Swagger Codegen or OpenAPI Generator: it doesn't just serve human developers — it also serves the growing class of AI consumers.

MCP (Model Context Protocol) was proposed and open-sourced by Anthropic in late 2024, with the goal of providing large language models with a standardized "tool-calling" interface spec — analogous to what USB did for hardware interoperability. Before MCP, every AI agent framework (LangChain, AutoGPT, etc.) had to implement its own logic for adapting to external APIs, forcing developers to repeatedly write tool descriptions and call wrappers for different frameworks. An MCP server is essentially a middleware process that exposes a standardized list of tools and calling interfaces to AI clients; the model only needs to know "what tools are available and what parameters they accept" — it doesn't need to understand the underlying HTTP request details. Claude, Cursor, Zed, and other mainstream AI tools now natively support MCP, and the ecosystem is expanding rapidly.

Why This Approach Is Worth Watching

The API tooling space isn't short on code generators. Cortex's value lies more in the word "unified." It consolidates artifacts that were previously scattered across multiple tools and workflows onto a single spec, using a single-source-of-truth approach to reduce inconsistency.

With AI agents proliferating rapidly, "making APIs natively callable by agents" is becoming a new infrastructure requirement. APIs used to only need to account for two types of consumers: human developers and frontend applications. Now there's a third, increasingly important category: machine consumers. By including MCP server generation as a default output, Cortex lands squarely on this trend.

As an open-source project, it also lowers the barrier to experimentation — teams can self-host, audit the generation logic, and avoid entrusting sensitive API spec assets to a third-party closed-source service.

Things Worth Keeping in Mind

Based on publicly available information, Cortex presents a clear product vision — but the actual quality of its generated outputs still needs hands-on verification. Whether the auto-generated SDKs follow idiomatic conventions in each language, how reliable the generated MCP servers are in real agent scenarios, and how well the tool handles complex API specs (deeply nested structures, custom extensions) are all dimensions worth examining carefully before adopting it.

For teams building external APIs or looking to connect existing interfaces to the AI agent ecosystem, Cortex offers a viable path to unifying multiple output types around a single spec source. It's worth adding to your evaluation list.