Add documentation infra with Mintlify

docs/README.md

@@ -0,0 +1,32 @@
+# ACP Documentation
+
+The ACP documentation uses [Mintlify](https://mintlify.com/).
+All files are MDX and can host custom components if there's a need to.
+
+## Running
+
+Run the following command to have the documentation live locally:
+
+```bash
+npm run docs
+```
+
+## Preview changes locally
+
+To preview the changes locally, run the following command:
+
+```bash
+mint dev
+```
+
+### Install the CLI
+
+Before running the site locally you need to install Mint's CLI:
+
+```bash
+npm i -g mint
+```
+
+## Deployment
+
+The documentation site is updated every time changes get to `main`.

docs/community/contributing.mdx

@@ -0,0 +1,10 @@
+---
+title: "Contributing"
+description: "How to participate in the development of ACP"
+---
+
+We welcome contributions from the community!
+
+All contributors must adhere to [Zed's Code of Conduct](https://zed.dev/code-of-conduct).
+
+For questions and discussions, please use GitHub Discussions.

docs/community/versioning.mdx

@@ -0,0 +1,4 @@
+---
+title: "Versioning"
+description: "Versioning policy for the Agent Client Protocol"
+---

docs/docs.json

@@ -0,0 +1,90 @@
+{
+  "$schema": "https://mintlify.com/docs.json",
+  "theme": "maple",
+  "name": "Agent Client Protocol",
+  "description": "The Agent Client Protocol (ACP) is a protocol that standardizes communication between code editors.",
+  "colors": {
+    "primary": "#0084d1",
+    "light": "#00bcff",
+    "dark": "#0084d1"
+  },
+  "background": {
+    "color": {
+      "light": "#f8f8f6",
+      "dark": "#100f0f"
+    }
+  },
+  "fonts": {
+    "heading": {
+      "family": "Lora",
+      "format": "woff2"
+    },
+    "body": {
+      "family": "Public Sans",
+      "format": "woff2"
+    }
+  },
+  "favicon": {
+    "light": "/logo/fav-light.png",
+    "dark": "/logo/fav-dark.png"
+  },
+  "navbar": {
+    "links": [
+      {
+        "label": "GitHub",
+        "href": "https://github.com/zed-industries/agent-client-protocol"
+      },
+      {
+        "label": "Zed Industries",
+        "href": "https://zed.dev"
+      }
+    ]
+  },
+  "navigation": {
+    "groups": [
+      {
+        "group": "Overview",
+        "pages": ["overview/introduction", "overview/architecture"]
+      },
+      {
+        "group": "Protocol",
+        "pages": [
+          "protocol/overview",
+          "protocol/initialization",
+          "protocol/session-setup",
+          "protocol/prompt-turn",
+          "protocol/content",
+          "protocol/tool-calls",
+          "protocol/agent-plan",
+          "protocol/schema"
+        ]
+      },
+      {
+        "group": "Libraries",
+        "pages": ["libraries/typescript", "libraries/rust"]
+      },
+      {
+        "group": "Community",
+        "pages": ["community/contributing", "community/versioning"]
+      }
+    ]
+  },
+  "logo": {
+    "light": "/logo/light.svg",
+    "dark": "/logo/dark.svg"
+  },
+  "seo": {
+    "metatags": {
+      "og:image": "https://raw.githubusercontent.com/modelcontextprotocol/docs/2eb6171ddbfeefde349dc3b8d5e2b87414c26250/images/og-image.png"
+    },
+    "indexing": "navigable"
+  },
+  "footer": {
+    "socials": {
+      "github": "https://github.com/zed-industries/agent-client-protocol"
+    }
+  },
+  "contextual": {
+    "options": ["copy", "view"]
+  }
+}

docs/images/mcp-proxy.d2

@@ -0,0 +1,34 @@
+'Code Editor': {near: top-center}
+
+'MCP Proxy': {near: center-left}
+# 'MCP Server ...': {
+#   near: center-right
+#   style: {
+#     stroke-dash: 3
+#   }
+# }
+" ---------------------------------------------- ": {
+  style: {
+    fill: transparent
+    font-color: transparent
+    stroke-width: 0
+  }
+}
+
+# Bottom row: Agent
+Agent: {near: bottom-center}
+
+# Connections
+'Code Editor' -> Agent: MCP Proxy Configuration {
+  style: {
+    stroke-dash: 3
+  }
+}
+
+# The agent connects up to the MCP servers
+Agent <-> 'MCP Proxy': MCP over stdio {direction: up}
+'MCP Proxy' <-> 'Code Editor': MCP over socket {
+  style: {
+    stroke-dash: 3
+  }
+}

docs/images/mcp.d2

@@ -0,0 +1,30 @@
+'Code Editor': {near: top-center}
+
+'MCP Server 1': {near: center-left}
+'MCP Server ...': {
+  near: center-right
+  style: {
+    stroke-dash: 3
+  }
+}
+" ----------------------- ": {
+  style: {
+    fill: transparent
+    font-color: transparent
+    stroke-width: 0
+  }
+}
+
+# Bottom row: Agent
+Agent: {near: bottom-center}
+
+# Connections
+'Code Editor' -> Agent: MCP Configuration {direction: down}
+
+# The agent connects up to the MCP servers
+Agent -> 'MCP Server 1': MCP {direction: up}
+Agent -> 'MCP Server ...': MCP {
+  style: {
+    stroke-dash: 3
+  }
+}

docs/images/server-client.d2

@@ -0,0 +1,17 @@
+# file generated by putting this code into https://play.d2lang.com/
+# and setting theme to Earth tones
+Code Editor -> agent1: stdio
+agent1: Agent 1
+Code Editor -> agent2: stdio
+agent2: Agent 2
+
+Code Editor -> "...": {
+  style: {
+    stroke-dash: 3
+  }
+}
+"...": {
+  style: {
+    stroke-dash: 3
+  }
+}

docs/libraries/rust.mdx

@@ -0,0 +1,4 @@
+---
+title: "Rust"
+description: "Rust library for the Agent Client Protocol"
+---

docs/libraries/typescript.mdx

@@ -0,0 +1,4 @@
+---
+title: "TypeScript"
+description: "TypeScript library for the Agent Client Protocol"
+---

docs/overview/architecture.mdx

@@ -0,0 +1,34 @@
+---
+title: "Architecture"
+description: "Overview of the Agent Client Protocol architecture"
+---
+
+The Agent Client Protocol defines a standard interface for communication between AI agents and client applications. The architecture is designed to be flexible, extensible, and platform-agnostic.
+
+## Design Philosophy
+
+The protocol architecture follows several key principles:
+
+1. **MCP-friendly**: The protocol is built on JSON-RPC, and re-uses MCP types where possible so that integrators don't need to build yet-another representation for common data types.
+2. **UX-first**: It is designed to solve the UX challenges of interacting with AI agents; ensuring there's enough flexibility to render clearly the agents intent, but is no more abstract than it needs to be.
+3. **Trusted**: ACP works when you're using a code editor to talk to a model you trust. You still have controls over the agent's tool calls, but the code editor gives the agent access to local files and MCP servers.
+
+## Setup
+
+When the user tries to connect to an agent, the editor boots the agent sub-process on demand, and all communication happens over stdin/stdout.
+
+Each connection can suppport several concurrent sessions, so you can have multiple trains of thought going on at once.
+
+![Server Client setup](../images/server-client.svg)
+
+ACP makes heavy use of JSON-RPC notifications to allow the agent to stream updates to the UI in real-time. It also uses JSON-RPC's bidrectional requests to allow the agent to make requests of the code editor: for example to request permissions for a tool call.
+
+## MCP
+
+Commonly the code editor will have user-configured MCP servers. When forwarding the prompt from the user, it passes configuration for these to the agent. This allows the agent to connect directly to the MCP server.
+
+![MCP Server connection](../images/mcp.svg)
+
+The code editor may itself also wish to export MCP based tools. Instead of trying to run MCP and ACP on the same socket, the code editor can provide its own MCP server as configuration. As agents may only support MCP over stdio, the code editor can provide a small proxy that tunnels requests back to itself:
+
+![MCP connection to self](../images/mcp-proxy.svg)

docs/overview/introduction.mdx

@@ -0,0 +1,48 @@
+---
+title: "Introduction"
+description: "Get started with the Agent Client Protocol (ACP)"
+---
+
+The Agent Client Protocol standardizes communication between code editors (IDEs, text-editors, etc.) and coding agents (programs that use generative AI to autonomously modify code).
+
+The protocol is still under development, but it should be complete enough to build interesting user experiences using it.
+
+## Why ACP?
+
+AI coding agents and editors are tightly coupled but interoperability isn't the default. Each editor must build custom integrations for every agent they want to support, and agents must implement editor-specific APIs to reach users.
+This creates several problems:
+
+- Integration overhead: Every new agent-editor combination requires custom work
+- Limited compatibility: Agents work with only a subset of available editors
+- Developer lock-in: Choosing an agent often means accepting their available interfaces
+
+ACP solves this by providing a standardized protocol for agent-editor communication, similar to how the [Language Server Protocol (LSP)](https://microsoft.github.io/language-server-protocol/) standardized language server integration.
+
+Agents that implement ACP work with any compatible editor. Editors that support ACP gain access to the entire ecosystem of ACP-compatible agents.
+This decoupling allows both sides to innovate independently while giving developers the freedom to choose the best tools for their workflow.
+
+## Overview
+
+ACP assumes that the user is primarily in their editor, and wants to reach out and use agents to assist them with specific tasks.
+
+Agents run as sub-processes of the code editor, and communicate using JSON-RPC over stdio. The protocol re-uses the JSON representations used in MCP where possible, but includes custom types for useful agentic coding UX elements, like displaying diffs.
+
+The default format for user-readable text is Markdown, which allows enough flexibility to represent rich formatting without requiring that the code editor is capable of rendering HTML.
+
+## Implementations
+
+Currently ACP is supported by:
+
+### Editors
+
+- [Zed](https://zed.dev)
+- [neovim](https://neovim.io) if you install the [CodeCompanion](https://codecompanion.olimorris.dev) plugin.
+
+### Agents
+
+- [Gemini](https://github.com/google-gemini/gemini-cli)
+- ... more coming soon ;)
+
+## Further reading
+
+For an overview of the architecture, see the [Architecture](./Architecture) section. For ... TODO