# Context Atlas

> A catalog of the sources vendors publish for coding agents: llms.txt indexes, docs, MCP servers, agent skills, rule files and CLIs. Use it to choose a tech stack, or to load the right sources for the stack a project already uses.

Last updated: 2026-10-23. The same data as JSON: https://contextatlas.dev/atlas.json. Each topic also has its own small file at https://contextatlas.dev/llms/<id>.txt, for example https://contextatlas.dev/llms/vercel.txt.

Other ways to query the catalog:

- MCP server (Streamable HTTP, no auth): https://contextatlas.dev/mcp, with the tools `search`, `get_topic` and `list_topics`. Add it with `claude mcp add --transport http contextatlas https://contextatlas.dev/mcp`.
- JSON API: https://contextatlas.dev/api/search?q=<words> (full-text search, optional `kind` and `limit`), https://contextatlas.dev/api/topics and https://contextatlas.dev/api/topics/<id>.

Docs for people and agents, each page as Markdown (all of them in one file: https://contextatlas.dev/llms-full.txt):

- [Docs](https://contextatlas.dev/docs/index.md): How to use Context Atlas from a coding agent or a browser, through the MCP server, the agent prompt, the llms.txt files and the JSON API.
- [Quickstart](https://contextatlas.dev/docs/quickstart.md): Connect the Context Atlas MCP server to your agent and run a first query, in about two minutes.
- [MCP server](https://contextatlas.dev/docs/mcp.md): What the Context Atlas MCP server does, and how to connect it to Claude Code, Codex, Cursor, VS Code and other clients.
- [MCP tools](https://contextatlas.dev/docs/mcp-tools.md): The three tools of the Context Atlas MCP server, with their inputs, example prompts and example answers.
- [Workflows](https://contextatlas.dev/docs/mcp-workflows.md): Typical tasks with the Context Atlas MCP server, from detecting a project's stack to fetching a vendor's llms.txt.
- [Troubleshooting](https://contextatlas.dev/docs/mcp-troubleshooting.md): What to do when the MCP server does not connect, times out or returns errors.
- [Submitting data](https://contextatlas.dev/docs/mcp-submissions.md): The planned write access to the MCP server for adding and updating catalog entries, with tokens and a review queue.
- [Site map](https://contextatlas.dev/docs/website.md): Every page and file on contextatlas.dev, what it is for and who it is for.
- [Reading a topic](https://contextatlas.dev/docs/topics.md): How to find and filter tools on the home page, and what each line of a topic means.
- [Give it to your agent](https://contextatlas.dev/docs/agents.md): Three ways to hand content from Context Atlas to a coding agent - a prompt, a link or Markdown - and when to use each.
- [JSON API](https://contextatlas.dev/docs/api.md): Read the catalog over HTTP with /api/topics, /api/topics/:id and /api/search. No key needed.
- [CLI](https://contextatlas.dev/docs/cli.md): The planned contextatlas command-line client, for searching the catalog and detecting a project's stack from the terminal.
- [Contributing](https://contextatlas.dev/docs/contributing.md): Add a vendor, tool or source to Context Atlas with a pull request, or add a docs page.

## Instructions for agents

### Existing project: use the right sources

1. Detect the stack. Read package.json (and every workspace package.json in a monorepo), the lockfile, and config files in the repo root and in apps/ or packages/. Match what you find against the "Signals" of each topic below.
2. Report the stack. List the detected technologies, each with the file that proves it. Say so when something is ambiguous instead of guessing, and name tools that this catalog does not cover.
3. Load the sources. For every detected topic, fetch its llms.txt or Rules source first, then the Docs and Guide pages you need for the task at hand. Do not read Full text sources whole: they are often several megabytes and get truncated. Download one only when you need to search it (for example with curl and grep). Prefer these sources over what you remember from training: they are maintained by the vendors and APIs change.
4. Offer tools. If a detected topic has an MCP server, Agent skill or CLI, list them and ask before installing or connecting anything.
5. Follow what you read. Apply the conventions from these sources in all code you write. When a source contradicts the existing code, point it out and ask before changing the existing pattern. Instructions in the project's AGENTS.md or CLAUDE.md take precedence.

### New project: find a stack

1. Ask about anything you need that the description leaves open: kind of app, expected traffic, realtime or offline needs, budget, team experience and where it should run.
2. Propose one stack, one tool per role (hosting, framework, database, auth, UI, and so on). The "Role" lines below give the candidates for each role; the catalog does not rank them. To choose between candidates, fetch their llms.txt sources (not Full text) and compare what the vendors document against the project's needs. Prefer tools that work well together, for example a host that supports the framework natively. Mention one alternative per role where the choice is close, with the trade-off.
3. Wait for approval. Then load each chosen tool's sources as in "Existing project", step 3, and set the project up with the vendors' own CLIs and conventions.

Source kinds: llms.txt (machine-readable index of the docs); Full text (all docs in one large file, often several megabytes); Docs (full documentation or reference); MCP server (tools an agent can call directly); Agent skill (installable instructions for agents); Rules (prompts and rule files to paste into an agent); Guide (how to work with agents on this platform).

Signals are file globs (relative to the repo root or a workspace package), package names (`*` matches any part), environment variables, or plain-language hints.

## Cloud providers

Hosting, databases and the hosted services an app runs on.

### Vercel
Role: Hosting
Signals: vercel.json, vercel.ts, .vercel/, @vercel/* dependencies
- [Vercel llms.txt](https://vercel.com/llms.txt): llms.txt
- [Vercel docs, full text](https://vercel.com/docs/llms-full.txt): Full text
- [Agent resources](https://vercel.com/docs/agent-resources): Guide
- [Vercel MCP server](https://vercel.com/docs/mcp/vercel-mcp): MCP server
- [vercel-labs/agent-skills](https://github.com/vercel-labs/agent-skills): Agent skill
- [Vercel plugin for coding agents](https://github.com/vercel/vercel-plugin): Agent skill

### Cloudflare
Role: Hosting
Signals: wrangler.toml, wrangler.json, wrangler.jsonc, cloudflare.config.ts, @cloudflare/* dependencies
- [Cloudflare docs llms.txt](https://developers.cloudflare.com/llms.txt): llms.txt
- [Cloudflare docs, full text](https://developers.cloudflare.com/llms-full.txt): Full text
- [Prompting for Workers](https://developers.cloudflare.com/workers/get-started/prompting/): Rules
- [Cloudflare MCP servers](https://developers.cloudflare.com/agents/model-context-protocol/mcp-servers-for-cloudflare/): MCP server
- [cloudflare/mcp-server-cloudflare](https://github.com/cloudflare/mcp-server-cloudflare): MCP server
- [cloudflare/skills](https://github.com/cloudflare/skills): Agent skill

### Railway
Role: Hosting
Signals: railway.json, railway.toml, nixpacks.toml
- [Railway docs llms.txt](https://docs.railway.com/llms.txt): llms.txt
- [Railway for agents](https://docs.railway.com/agents.md): Guide
- [Railway MCP server](https://docs.railway.com/ai/mcp-server): MCP server
- [railwayapp/railway-mcp-server](https://github.com/railwayapp/railway-mcp-server): MCP server
- [Railway agent skills](https://docs.railway.com/ai/agent-skills): Agent skill
- [railwayapp/railway-skills](https://github.com/railwayapp/railway-skills): Agent skill

### Supabase
Role: Postgres database and backend
Signals: supabase/, supabase/config.toml, @supabase/supabase-js dependency, @supabase/ssr dependency
- [Supabase llms.txt](https://supabase.com/llms.txt): llms.txt
- [AI prompts for Supabase](https://supabase.com/docs/guides/getting-started/ai-prompts): Rules
- [AI skills for Supabase](https://supabase.com/docs/guides/getting-started/ai-skills): Agent skill
- [supabase/agent-skills](https://github.com/supabase/agent-skills): Agent skill
- [Supabase MCP server](https://supabase.com/docs/guides/getting-started/mcp): MCP server
- [supabase-community/supabase-mcp](https://github.com/supabase-community/supabase-mcp): MCP server

### Neon
Role: Postgres database
Signals: @neondatabase/serverless dependency, DATABASE_URL pointing to *.neon.tech
- [Neon llms.txt](https://neon.com/llms.txt): llms.txt
- [AI rules for Neon](https://neon.com/docs/ai/ai-rules): Rules
- [Neon MCP server](https://neon.com/docs/ai/neon-mcp-server): MCP server
- [neondatabase/mcp-server-neon](https://github.com/neondatabase/mcp-server-neon): MCP server
- [neondatabase/agent-skills](https://github.com/neondatabase/agent-skills): Agent skill

### Convex
Role: Database and backend
Signals: convex/, convex.json, convex dependency
- [Convex llms.txt](https://docs.convex.dev/llms.txt): llms.txt
- [Convex and AI](https://docs.convex.dev/ai): Guide
- [Convex rules](https://convex.link/convex_rules.txt): Rules
- [Convex MCP server](https://docs.convex.dev/ai/convex-mcp-server): MCP server
- [Convex agent skills](https://docs.convex.dev/ai/agent-skills): Agent skill
- [get-convex/agent-skills](https://github.com/get-convex/agent-skills): Agent skill

### PlanetScale
Role: MySQL and Postgres database
Signals: @planetscale/database dependency, pscale.yml
- [PlanetScale llms.txt](https://planetscale.com/llms.txt): llms.txt

### Turso
Role: SQLite database
Signals: @libsql/client dependency, @tursodatabase/* dependencies
- [Turso docs llms.txt](https://docs.turso.tech/llms.txt): llms.txt

### Upstash
Role: Redis cache and queues
Signals: @upstash/* dependencies
- [Upstash docs llms.txt](https://upstash.com/docs/llms.txt): llms.txt

### Claude Platform
Role: AI models
Signals: @anthropic-ai/* dependencies, ANTHROPIC_API_KEY env var
- [Claude platform llms.txt](https://platform.claude.com/llms.txt): llms.txt
- [Claude platform docs, full text](https://platform.claude.com/llms-full.txt): Full text

### OpenAI Developer Platform
Role: AI models
Signals: openai dependency, @openai/* dependencies, OPENAI_API_KEY env var
- [OpenAI Developers llms.txt](https://developers.openai.com/llms.txt): llms.txt
- [OpenAI Docs MCP server](https://developers.openai.com/learn/docs-mcp): MCP server

### OpenRouter
Role: AI gateway
Signals: OPENROUTER_API_KEY env var, openrouter.ai/api/v1 base URL, model IDs such as openai/gpt-4o
- [OpenRouter llms.txt](https://openrouter.ai/llms.txt): llms.txt
- [OpenRouter MCP server setup](https://openrouter.ai/docs/guides/overview/mcp-server.md): MCP server

### Clerk
Role: Auth
Signals: @clerk/* dependencies
- [Clerk llms.txt](https://clerk.com/llms.txt): llms.txt
- [AI prompts for Clerk](https://clerk.com/docs/guides/development/ai-prompts): Rules

### Stripe
Role: Payments
Signals: stripe dependency, @stripe/* dependencies
- [Stripe docs llms.txt](https://docs.stripe.com/llms.txt): llms.txt
- [Building with LLMs](https://docs.stripe.com/building-with-llms): Guide
- [Stripe MCP server](https://docs.stripe.com/mcp): MCP server

### Resend
Role: Email
Signals: resend dependency, react-email dependency, @react-email/* dependencies
- [Resend docs llms.txt](https://resend.com/docs/llms.txt): llms.txt
- [Resend MCP server](https://resend.com/docs/mcp-server): MCP server

### Sentry
Role: Monitoring
Signals: @sentry/* dependencies, sentry.*.config.ts
- [Sentry docs llms.txt](https://docs.sentry.io/llms.txt): llms.txt
- [Sentry MCP server](https://docs.sentry.io/product/sentry-mcp/): MCP server

### Contabo
Role: Hosting
Signals: cntb CLI, Contabo Terraform provider
- [Contabo docs llms.txt](https://docs.contabo.com/llms.txt): llms.txt
- [Contabo API documentation](https://docs.contabo.com/docs/references/api-documentation/): Docs
- [cntb CLI reference](https://docs.contabo.com/docs/references/cli-cntb/): Docs
- [contabo/cntb](https://github.com/contabo/cntb): Docs

### Hetzner
Role: Hosting
Signals: HCLOUD_TOKEN env var, hcloud CLI, Hetzner Cloud Terraform provider
- [Hetzner docs llms.txt](https://docs.hetzner.com/llms.txt): llms.txt
- [Hetzner Cloud API getting started](https://docs.hetzner.com/cloud/api/getting-started/using-api/): Docs
- [hetznercloud/cli (hcloud)](https://github.com/hetznercloud/cli): Docs

### OVHcloud
Role: Hosting
Signals: OVH_APPLICATION_KEY env var, ovhcloud CLI
- [OVHcloud docs llms.txt](https://docs.ovhcloud.com/en/llms.txt): llms.txt
- [OVHcloud CLI llms.txt](https://docs.ovhcloud.com/en/llms/manage-operate-cli/llms.txt): llms.txt
- [OVHcloud API](https://docs.ovhcloud.com/en/llms/manage-operate-api/llms.txt): Docs
- [ovh/ovhcloud-cli](https://github.com/ovh/ovhcloud-cli): Docs

### DigitalOcean
Role: Hosting
Signals: DIGITALOCEAN_ACCESS_TOKEN env var, doctl CLI, digitalocean Terraform provider
- [DigitalOcean docs llms.txt](https://docs.digitalocean.com/llms.txt): llms.txt
- [DigitalOcean MCP servers](https://docs.digitalocean.com/reference/mcp/): MCP server
- [doctl reference](https://docs.digitalocean.com/reference/doctl/): Docs
- [digitalocean/doctl](https://github.com/digitalocean/doctl): Docs

### Hostinger
Role: Hosting
Signals: HOSTINGER_API_TOKEN env var, hostinger-api-mcp, hostinger CLI
- [Hostinger docs llms.txt](https://docs.hostinger.com/llms.txt): llms.txt
- [Hostinger API and CLI reference](https://docs.hostinger.com/api-reference/cli): Docs
- [hostinger-api-mcp (npm)](https://www.npmjs.com/package/hostinger-api-mcp): MCP server

### Fly.io
Role: Hosting
Signals: fly.toml, flyctl CLI
- [Fly.io llms.txt](https://fly.io/llms.txt): llms.txt
- [Fly.io docs, full text](https://docs.fly.io/llms-full.txt): Full text
- [flyctl reference](https://fly.io/docs/flyctl/): Docs
- [superfly/flyctl](https://github.com/superfly/flyctl): Docs

### Render
Role: Hosting
Signals: render.yaml, render CLI
- [Render docs llms.txt](https://render.com/docs/llms.txt): llms.txt
- [Render for agents](https://render.com/agents.md): Guide
- [Render MCP server](https://render.com/docs/mcp-server): MCP server
- [Render agent skills](https://render.com/.well-known/agent-skills/index.json): Agent skill
- [Render CLI](https://render.com/docs/cli): Docs
- [Render CLI reference](https://render.com/docs/cli-reference): Docs
- [render-oss/cli](https://github.com/render-oss/cli): Docs

### Netlify
Role: Hosting
Signals: netlify.toml, .netlify/, netlify-cli dependency, @netlify/* dependencies
- [Netlify llms.txt](https://docs.netlify.com/llms.txt): llms.txt
- [Build with AI on Netlify](https://docs.netlify.com/build/build-with-ai/overview/): Guide
- [netlify/netlify-mcp](https://github.com/netlify/netlify-mcp): MCP server
- [netlify/context-and-tools](https://github.com/netlify/context-and-tools): Agent skill
- [Netlify CLI: get started](https://docs.netlify.com/api-and-cli-guides/cli-guides/get-started-with-cli/): Docs
- [netlify/cli](https://github.com/netlify/cli): Docs

### Tailscale
Role: Networking
Signals: TS_AUTHKEY env var, tailscale Docker image, tailscale Terraform provider
- [Tailscale docs llms.txt](https://tailscale.com/docs/llms.txt): llms.txt
- [Tailscale docs](https://tailscale.com/docs): Docs

## Frameworks

Frameworks and libraries the app's code is written with.

### Next.js
Role: Web framework
Signals: next.config.{js,ts,mjs}, next dependency, app/ or pages/ directory
- [Next.js docs llms.txt](https://nextjs.org/docs/llms.txt): llms.txt
- [Next.js docs, full text](https://nextjs.org/docs/llms-full.txt): Full text
- [AI coding agents](https://nextjs.org/docs/app/guides/ai-agents): Guide
- [Next.js MCP endpoint](https://nextjs.org/docs/app/guides/mcp): MCP server
- [vercel/next-devtools-mcp](https://github.com/vercel/next-devtools-mcp): MCP server

### vinext
Role: Web framework
Signals: vinext dependency, @vinext/cloudflare dependency, vite.config.ts with vinext()
- [vinext documentation](https://vinext.dev/docs): Docs
- [cloudflare/vinext](https://github.com/cloudflare/vinext): Docs
- [vinext migration skill](https://github.com/cloudflare/vinext/tree/main/.agents/skills): Agent skill

### Svelte and SvelteKit
Role: Web framework
Signals: svelte.config.js, **/*.svelte, @sveltejs/kit dependency
- [Svelte llms.txt](https://svelte.dev/llms.txt): llms.txt
- [Svelte docs, full text](https://svelte.dev/llms-full.txt): Full text
- [Docs for LLMs](https://svelte.dev/docs/llms): Docs
- [Svelte MCP server](https://svelte.dev/docs/mcp/overview): MCP server
- [sveltejs/mcp](https://github.com/sveltejs/mcp): MCP server

### Nuxt
Role: Web framework
Signals: nuxt.config.ts, nuxt dependency
- [Nuxt llms.txt](https://nuxt.com/llms.txt): llms.txt

### Astro
Role: Web framework
Signals: astro.config.mjs, **/*.astro, astro dependency
- [Building Astro sites with AI tools](https://docs.astro.build/en/guides/build-with-ai/): Guide

### TanStack
Role: Web framework
Signals: @tanstack/* dependencies
- [TanStack llms.txt](https://tanstack.com/llms.txt): llms.txt

### Hono
Role: API framework
Signals: hono dependency
- [Hono llms.txt](https://hono.dev/llms.txt): llms.txt

### Expo
Role: Mobile framework
Signals: expo dependency, eas.json, app.json with expo key
- [Expo docs llms.txt](https://docs.expo.dev/llms.txt): llms.txt

### React
Role: UI library
Signals: react dependency, **/*.{jsx,tsx}
- [React llms.txt](https://react.dev/llms.txt): llms.txt
- [React API reference](https://react.dev/reference/react): Docs

### shadcn/ui
Role: UI components
Signals: components.json, components/ui/
- [shadcn/ui llms.txt](https://ui.shadcn.com/llms.txt): llms.txt
- [shadcn MCP server](https://ui.shadcn.com/docs/mcp): MCP server

### Tailwind CSS
Role: Styling
Signals: tailwindcss dependency, tailwind.config.*, @import "tailwindcss" in CSS
- [Tailwind CSS docs](https://tailwindcss.com/docs): Docs

### Motion
Role: Animation
Signals: motion dependency, framer-motion dependency
- [Motion docs](https://motion.dev/docs): Docs

### AI SDK
Role: AI
Signals: ai dependency, @ai-sdk/* dependencies
- [AI SDK docs, full text](https://ai-sdk.dev/llms.txt): Full text
- [AI SDK introduction](https://ai-sdk.dev/docs/introduction): Docs

### Cloudflare Agents
Role: AI
Signals: agents dependency, Durable Object bindings named *Agent
- [Cloudflare Agents docs](https://developers.cloudflare.com/agents/): Docs
- [cloudflare/agents](https://github.com/cloudflare/agents): Docs

### Mastra
Role: AI
Signals: @mastra/* dependencies
- [Mastra llms.txt](https://mastra.ai/llms.txt): llms.txt

### Drizzle ORM
Role: ORM
Signals: drizzle.config.ts, drizzle-orm dependency, drizzle-kit dependency
- [Drizzle llms.txt](https://orm.drizzle.team/llms.txt): llms.txt

### Prisma
Role: ORM
Signals: prisma/schema.prisma, prisma.config.ts, @prisma/client dependency
- [Prisma docs llms.txt](https://www.prisma.io/docs/llms.txt): llms.txt
- [Prisma MCP server](https://www.prisma.io/docs/ai/tools/mcp-server): MCP server

### Better Auth
Role: Auth
Signals: better-auth dependency, auth.ts with betterAuth()
- [Better Auth llms.txt](https://www.better-auth.com/llms.txt): llms.txt
- [Better Auth docs](https://www.better-auth.com/docs/introduction): Docs

### Zod
Role: Validation
Signals: zod dependency
- [Zod llms.txt](https://zod.dev/llms.txt): llms.txt

### Vite
Role: Build tool
Signals: vite.config.{ts,js}, vite dependency
- [Vite llms.txt](https://vite.dev/llms.txt): llms.txt

### TypeScript
Role: Language
Signals: tsconfig.json
- [TypeScript handbook](https://www.typescriptlang.org/docs/): Docs

## Standards

The open formats agents use to find knowledge and tools.

### Agent Skills
Role: Instructions
Signals: **/SKILL.md, .agents/skills/, .claude/skills/
- [agentskills.io](https://agentskills.io/home): Docs
- [Skill specification](https://agentskills.io/specification): Docs
- [Agent Skills llms.txt](https://agentskills.io/llms.txt): llms.txt
- [skills.sh directory](https://skills.sh): Agent skill
- [anthropics/skills](https://github.com/anthropics/skills): Agent skill
- [Agent Skills in Claude](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview): Guide

### Model Context Protocol
Role: Tools
Signals: .mcp.json, mcp.json, @modelcontextprotocol/sdk dependency
- [MCP llms.txt](https://modelcontextprotocol.io/llms.txt): llms.txt
- [MCP docs, full text](https://modelcontextprotocol.io/llms-full.txt): Full text
- [MCP specification](https://modelcontextprotocol.io/specification/latest): Docs
- [MCP registry](https://registry.modelcontextprotocol.io): MCP server
- [Reference servers](https://github.com/modelcontextprotocol/servers): MCP server
- [GitHub MCP server](https://github.com/github/github-mcp-server): MCP server
- [Playwright MCP](https://github.com/microsoft/playwright-mcp): MCP server

### Agent2Agent (A2A)
Role: Agent protocol
Signals: @a2a-js/sdk dependency, a2a-sdk Python dependency, /.well-known/agent-card.json
- [A2A llms.txt](https://a2a-protocol.org/llms.txt): llms.txt
- [A2A protocol specification](https://a2a-protocol.org/latest/specification/): Docs
- [a2aproject/A2A](https://github.com/a2aproject/A2A): Docs

### AGENTS.md
Role: Instructions
Signals: AGENTS.md, CLAUDE.md, .github/copilot-instructions.md
- [agents.md](https://agents.md): Docs
- [Copilot repository instructions](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions): Guide

### llms.txt
Role: Docs index
Signals: public/llms.txt, a route that serves /llms.txt, e.g. app/llms.txt/route.ts
- [llmstxt.org](https://llmstxt.org): Docs
- [llms.txt directory](https://directory.llmstxt.cloud): Guide

### Documentation servers
Role: Docs index
- [Context7](https://context7.com): MCP server
- [upstash/context7](https://github.com/upstash/context7): MCP server
- [GitMCP](https://gitmcp.io): MCP server

## CLIs

Command-line tools agents run to build, deploy and manage the stack.

### Vercel CLI
Role: Deploy
Signals: vercel dependency, .vercel/project.json
- [Vercel CLI](https://vercel.com/docs/cli): Docs

### Wrangler and cf
Role: Deploy
Signals: wrangler dependency, cf dependency
- [Wrangler](https://developers.cloudflare.com/workers/wrangler/): Docs
- [cloudflare/cf](https://github.com/cloudflare/cf): Docs

### Railway CLI
Role: Deploy
Signals: railway.json
- [Railway CLI](https://docs.railway.com/cli): Docs

### Supabase CLI
Role: Database
Signals: supabase/config.toml, supabase dependency
- [Supabase CLI reference](https://supabase.com/docs/reference/cli/introduction): Docs

### Neon CLI
Role: Database
Signals: neonctl dependency
- [Neon CLI](https://neon.com/docs/reference/neon-cli): Docs

### Convex CLI
Role: Database
Signals: convex dependency
- [Convex CLI](https://docs.convex.dev/cli): Docs

### Drizzle Kit and Prisma CLI
Role: Database
Signals: drizzle-kit dependency, prisma dependency
- [Drizzle Kit](https://orm.drizzle.team/docs/kit-overview): Docs
- [Prisma CLI reference](https://www.prisma.io/docs/orm/reference/prisma-cli-reference): Docs

### Framework CLIs
Role: Scaffold
Signals: next, vinext, sv or expo in package.json scripts
- [Next.js CLI](https://nextjs.org/docs/app/api-reference/cli): Docs
- [create-vinext-app](https://github.com/cloudflare/vinext/tree/main/packages/create-vinext-app): Docs
- [Svelte CLI (sv)](https://svelte.dev/docs/cli/overview): Docs
- [Expo CLI](https://docs.expo.dev/more/expo-cli/): Docs

### shadcn CLI
Role: Scaffold
Signals: components.json
- [shadcn CLI](https://ui.shadcn.com/docs/cli): Docs

### skills CLI
Role: Agent tooling
Signals: .agents/skills/, skills-lock.json
- [vercel-labs/skills](https://github.com/vercel-labs/skills): Docs

### MCP Inspector
Role: Agent tooling
Signals: @modelcontextprotocol/inspector dependency
- [modelcontextprotocol/inspector](https://github.com/modelcontextprotocol/inspector): Docs

### Coding agent CLIs
Role: Agent tooling
Signals: CLAUDE.md, AGENTS.md, .claude/, .codex/, .gemini/
- [Claude Code docs llms.txt](https://code.claude.com/docs/llms.txt): llms.txt
- [openai/codex](https://github.com/openai/codex): Docs
- [google-gemini/gemini-cli](https://github.com/google-gemini/gemini-cli): Docs

### GitHub CLI
Role: Workflow
Signals: .github/
- [gh manual](https://cli.github.com/manual/): Docs

### Stripe CLI
Role: Workflow
Signals: stripe dependency
- [Stripe CLI](https://docs.stripe.com/stripe-cli): Docs

### Tailscale CLI
Role: Networking
Signals: tailscaled service, tailscale install step in a Dockerfile or CI workflow
- [Tailscale CLI reference](https://tailscale.com/docs/reference/tailscale-cli): Docs
- [tailscale/tailscale](https://github.com/tailscale/tailscale): Docs

### Docker
Role: Containers
Signals: Dockerfile, compose.yaml, docker-compose.yml
- [Docker docs llms.txt](https://docs.docker.com/llms.txt): llms.txt
- [docker CLI reference](https://docs.docker.com/reference/cli/docker/): Docs

### Turborepo
Role: Monorepo
Signals: turbo.json, turbo dependency
- [Turborepo llms.txt](https://turborepo.com/llms.txt): llms.txt
- [Turborepo reference](https://turborepo.com/docs/reference): Docs

### Nx
Role: Monorepo
Signals: nx.json, **/project.json
- [Nx llms.txt](https://nx.dev/llms.txt): llms.txt
- [Nx commands](https://nx.dev/docs/reference/nx-commands): Docs

### pnpm
Role: Package manager
Signals: pnpm-lock.yaml, pnpm-workspace.yaml
- [pnpm workspaces](https://pnpm.io/workspaces): Docs
- [pnpm CLI](https://pnpm.io/cli/add): Docs
- [monorepo.tools](https://monorepo.tools): Guide

### Bun
Role: Runtime
Signals: bun.lock, bun.lockb, bunfig.toml
- [Bun llms.txt](https://bun.com/llms.txt): llms.txt
- [bun install](https://bun.com/docs/cli/install): Docs

### Vitest
Role: Testing
Signals: vitest.config.ts, vitest dependency
- [Vitest llms.txt](https://vitest.dev/llms.txt): llms.txt
- [Vitest CLI](https://vitest.dev/guide/cli): Docs

### Playwright
Role: Testing
Signals: playwright.config.ts, @playwright/test dependency
- [Playwright CLI](https://playwright.dev/docs/test-cli): Docs
- [Playwright MCP](https://github.com/microsoft/playwright-mcp): MCP server

# Docs

## Docs

> How to use Context Atlas from a coding agent or a browser, through the MCP server, the agent prompt, the llms.txt files and the JSON API.

Context Atlas is a catalog of the sources that vendors publish for coding agents: llms.txt indexes, docs, MCP servers, agent skills, rule files and CLIs. It exists so that a project can be built and run entirely from inside an agent harness such as Claude Code, Codex or Cursor, without a person opening dashboards or vendor consoles.

The catalog itself is small. Its value is that your agent finds the right, current, vendor-maintained sources for a stack instead of relying on what it remembers from training.

### Three ways in

| You want to… | Use | Start here |
| --- | --- | --- |
| Let an agent search the catalog with tools | The MCP server at `https://contextatlas.dev/mcp` | [MCP server](https://contextatlas.dev/docs/mcp) |
| Point an agent at the catalog with one sentence | The prompt on [/agent](https://contextatlas.dev/agent) | [Give it to your agent](https://contextatlas.dev/docs/agents) |
| Read the catalog yourself or from a script | The [home page](https://contextatlas.dev/), [/llms.txt](https://contextatlas.dev/llms.txt) and the [JSON API](https://contextatlas.dev/docs/api) | [Site map](https://contextatlas.dev/docs/website) |

Nothing needs an account, a key or a login.

### New here?

Follow the [Quickstart](https://contextatlas.dev/docs/quickstart). It connects the MCP server to your agent and runs a first query in about two minutes.

### For agents

Every page of these docs is also available as Markdown: add `.md` to the URL, for example [/docs/mcp.md](https://contextatlas.dev/docs/mcp.md). [/llms.txt](https://contextatlas.dev/llms.txt) links all of them, and [/llms-full.txt](https://contextatlas.dev/llms-full.txt) contains the catalog and every docs page in one file.

## Quickstart

> Connect the Context Atlas MCP server to your agent and run a first query, in about two minutes.

### 1. Connect the MCP server

The server lives at `https://contextatlas.dev/mcp`. It uses Streamable HTTP and needs no key. In Claude Code, run this in your terminal:

```bash
claude mcp add --transport http contextatlas https://contextatlas.dev/mcp
```

Using Cursor, Codex, VS Code or another client? Copy its snippet from [Connect a client](https://contextatlas.dev/docs/mcp#connect-a-client) instead.

### 2. Check that it is connected

Start a new session of your agent and list the MCP servers. In Claude Code, run `claude mcp list` in the terminal or type `/mcp` inside a session. `contextatlas` should show as connected, with three tools: `search`, `get_topic` and `list_topics`.

### 3. Ask your first question

Open your project and ask the agent, for example:

```text
Use the contextatlas MCP server to detect the stack of this repository and load the docs for it.
```

The agent reads your `package.json` and config files, calls `search` for what it finds, then `get_topic` for each tool, and fetches the llms.txt or rule files the catalog points to. For a new project, ask instead:

```text
Use contextatlas to propose a stack for a booking app with payments. Explain the trade-offs before you set anything up.
```

### No MCP support?

Paste the one-sentence prompt from [/agent](https://contextatlas.dev/agent) into any agent with web access. It points the agent to [/llms.txt](https://contextatlas.dev/llms.txt), which holds the same catalog and instructions as plain text. See [Give it to your agent](https://contextatlas.dev/docs/agents).

### Next

- [MCP tools](https://contextatlas.dev/docs/mcp-tools): what each tool takes and returns
- [Workflows](https://contextatlas.dev/docs/mcp-workflows): typical tasks from start to finish
- [Troubleshooting](https://contextatlas.dev/docs/mcp-troubleshooting): when the connection fails

## MCP server

> What the Context Atlas MCP server does, and how to connect it to Claude Code, Codex, Cursor, VS Code and other clients.

### What it does

The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) lets an agent call tools on a server. The Context Atlas MCP server gives your agent three read-only tools over the whole catalog:

- `search`: find tools by name, role or detection signal, such as `database`, `auth` or `turbo.json`
- `get_topic`: every source of one tool, with its role and detection signals
- `list_topics`: the whole catalog in short form, for proposing a stack

With it, an agent can work out which llms.txt, docs, MCP servers, skills and CLIs fit the project in front of it, without you pasting links. See [MCP tools](https://contextatlas.dev/docs/mcp-tools) for inputs and example answers.

### Why use it

- **Current sources instead of training data.** Vendors change APIs faster than models are retrained. The catalog points to what the vendors maintain themselves.
- **The agent picks what it needs.** Instead of loading a large file into context, it searches and fetches only the topics of your stack.
- **No setup cost.** No account, no key, no local install. The server is stateless, so deploys never drop your session.

### Server details

| Setting | Value |
| --- | --- |
| URL | `https://contextatlas.dev/mcp` |
| Transport | Streamable HTTP (JSON responses, no sessions) |
| Auth | None |
| Tools | `search`, `get_topic`, `list_topics`, all read-only |

Clients that still use the older SSE transport cannot connect. Use the HTTP or "streamable-http" type in their config, or the [stdio bridge](https://contextatlas.dev/docs/mcp#clients-with-stdio-only).

### Connect a client

Pick your client. After adding the server, start a new session or reload the client so it picks up the tools, then check with the steps in [Verify the connection](https://contextatlas.dev/docs/mcp#verify-the-connection).

#### Claude Code

```bash
claude mcp add --transport http contextatlas https://contextatlas.dev/mcp
```

This adds the server for the current project on your machine. Add `--scope user` to use it in every project, or `--scope project` to write it to `.mcp.json` and share it with your team through the repository:

```json
{
  "mcpServers": {
    "contextatlas": {
      "type": "http",
      "url": "https://contextatlas.dev/mcp"
    }
  }
}
```

#### Codex

```bash
codex mcp add contextatlas --url https://contextatlas.dev/mcp
```

Or add it to `~/.codex/config.toml` by hand:

```toml
[mcp_servers.contextatlas]
url = "https://contextatlas.dev/mcp"
```

#### Cursor

Add the server to `.cursor/mcp.json` in your project, or to `~/.cursor/mcp.json` for all projects:

```json
{
  "mcpServers": {
    "contextatlas": {
      "url": "https://contextatlas.dev/mcp"
    }
  }
}
```

#### VS Code

For GitHub Copilot in agent mode, add the server to `.vscode/mcp.json` in your workspace:

```json
{
  "servers": {
    "contextatlas": {
      "type": "http",
      "url": "https://contextatlas.dev/mcp"
    }
  }
}
```

Or add it to your user profile from the terminal:

```bash
code --add-mcp '{"name":"contextatlas","type":"http","url":"https://contextatlas.dev/mcp"}'
```

#### Gemini CLI

```bash
gemini mcp add --transport http contextatlas https://contextatlas.dev/mcp
```

Or in `~/.gemini/settings.json`:

```json
{
  "mcpServers": {
    "contextatlas": {
      "httpUrl": "https://contextatlas.dev/mcp"
    }
  }
}
```

#### Windsurf

In `~/.codeium/windsurf/mcp_config.json`:

```json
{
  "mcpServers": {
    "contextatlas": {
      "serverUrl": "https://contextatlas.dev/mcp"
    }
  }
}
```

#### OpenCode

In `opencode.json` in your project, or `~/.config/opencode/opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "contextatlas": {
      "type": "remote",
      "url": "https://contextatlas.dev/mcp"
    }
  }
}
```

#### Claude Desktop and claude.ai

Add a custom connector in the settings under Connectors, with the URL `https://contextatlas.dev/mcp`.

#### Clients with stdio only

Clients that can only start local MCP servers can reach the remote server through [mcp-remote](https://www.npmjs.com/package/mcp-remote), which needs Node.js:

```json
{
  "mcpServers": {
    "contextatlas": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://contextatlas.dev/mcp"]
    }
  }
}
```

#### Other clients

Any client that supports remote MCP servers over Streamable HTTP works. Use the URL `https://contextatlas.dev/mcp`, no headers and no auth. Config keys differ between clients; look for `url`, `httpUrl` or `serverUrl` and a type such as `http` or `streamable-http`.

### Verify the connection

In the client:

- **Claude Code:** `claude mcp list` in the terminal, or `/mcp` inside a session.
- **Codex:** `codex mcp list`, or `/mcp` inside a session.
- **Others:** the MCP or tools panel should list `contextatlas` with three tools.

From a terminal, without any client. This lists the tools and is the fastest way to rule out network problems:

```bash
curl -sS https://contextatlas.dev/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

The answer is JSON with `"name": "search"`, `"name": "get_topic"` and `"name": "list_topics"`. If it is not, see [Troubleshooting](https://contextatlas.dev/docs/mcp-troubleshooting).

### Next

- [MCP tools](https://contextatlas.dev/docs/mcp-tools): inputs, example prompts and example answers
- [Workflows](https://contextatlas.dev/docs/mcp-workflows): detect a stack, fetch a vendor's llms.txt, propose a stack

## MCP tools

> The three tools of the Context Atlas MCP server, with their inputs, example prompts and example answers.

All tools are read-only and answer with JSON as text. You rarely call them by name: ask your agent in plain language and it picks the tool. The example prompts below show what tends to trigger each one.

### search

Full-text search over tools (called topics) and their sources. It matches names, roles, regions, detection signals (files, dependencies, environment variables), source titles and URLs. Every word must match, as a prefix, so `post` finds Postgres.

| Input | Type | Description |
| --- | --- | --- |
| `query` | string, 1 to 200 characters | Words to search for, such as `database`, `vercel mcp` or `turbo.json` |
| `kind` | optional | Only return sources of this kind: `llms`, `full`, `docs`, `mcp`, `skill`, `rules` or `guide` |
| `limit` | optional, 1 to 50 | Maximum number of topics, default 10 |

Each result has the `topic` (without its sources), the matching `sources` and a `score` (lower is better). When the topic itself matched, `sources` holds all of its sources; when only some sources matched, just those.

**Example prompts**

- "Which Postgres hosts does contextatlas know?"
- "Find the MCP server for Vercel in contextatlas."
- "This repo has a turbo.json. What does contextatlas have for it?"

**Example call and answer** (shortened)

```json
{ "query": "neon", "limit": 1 }
```

```json
{
  "query": "neon",
  "results": [
    {
      "topic": {
        "id": "neon",
        "name": "Neon",
        "role": "Postgres database",
        "signals": [
          { "type": "dependency", "pattern": "@neondatabase/serverless" },
          { "type": "hint", "pattern": "DATABASE_URL pointing to *.neon.tech" }
        ],
        "region": { "id": "cloud", "name": "Cloud providers" }
      },
      "sources": [
        { "kind": "llms", "title": "Neon llms.txt", "url": "https://neon.com/llms.txt" },
        { "kind": "mcp", "title": "Neon MCP server", "url": "https://neon.com/docs/ai/neon-mcp-server" }
      ],
      "score": -4.32
    }
  ]
}
```

### get_topic

Everything the catalog has on one tool: its role, region, detection signals and all sources, plus `llmsTxt`, the URL of the topic's own small llms.txt file.

| Input | Type | Description |
| --- | --- | --- |
| `id` | string | Topic id as returned by `search` or `list_topics`, such as `vercel`, `nextjs` or `drizzle` |

**Example prompts**

- "Get the contextatlas topic for Drizzle and read its llms.txt."
- "What sources does contextatlas list for Cloudflare?"

**Example call and answer** (shortened)

```json
{ "id": "drizzle" }
```

```json
{
  "updatedAt": "2026-10-23",
  "topic": {
    "id": "drizzle",
    "name": "Drizzle ORM",
    "role": "ORM",
    "signals": [
      { "type": "file", "pattern": "drizzle.config.ts" },
      { "type": "dependency", "pattern": "drizzle-orm" }
    ],
    "sources": [
      { "kind": "llms", "title": "Drizzle llms.txt", "url": "https://orm.drizzle.team/llms.txt" }
    ],
    "region": { "id": "frameworks", "name": "Frameworks" },
    "llmsTxt": "https://contextatlas.dev/llms/drizzle.txt"
  }
}
```

An unknown id returns an error result, so the agent knows to search instead:

```json
{ "error": "Unknown topic \"nope\". Use search or list_topics to find ids." }
```

### list_topics

Every tool in the catalog with its id, name, role and region, without sources. Agents use it to find the candidates for each role, then call `get_topic` and read their llms.txt sources to choose. The catalog does not rank tools.

| Input | Type | Description |
| --- | --- | --- |
| `region` | optional string | Only this region: `cloud`, `frameworks`, `standards` or `clis` |

**Example prompts**

- "List the hosting options in contextatlas and pick one for a Next.js app."
- "What agent standards does contextatlas cover?"

**Example call and answer** (shortened)

```json
{ "region": "standards" }
```

```json
{
  "updatedAt": "2026-10-23",
  "topics": [
    {
      "id": "agent-skills",
      "name": "Agent Skills",
      "role": "Instructions",
      "region": "standards"
    },
    {
      "id": "agents-md",
      "name": "AGENTS.md",
      "role": "Instructions",
      "region": "standards"
    }
  ]
}
```

### Source kinds

The `kind` of a source tells the agent what to do with it:

| Kind | Meaning | What the agent should do |
| --- | --- | --- |
| `llms` | llms.txt, a machine-readable index of the docs | Fetch first |
| `rules` | Prompts and rule files to paste into an agent | Fetch first and follow |
| `guide` | How to work with agents on this platform | Read when relevant |
| `docs` | Full documentation or reference | Fetch the pages the task needs |
| `full` | All docs in one file, often several megabytes | Download and search it, never read it whole |
| `mcp` | An MCP server of the vendor | Offer to connect it, ask first |
| `skill` | Installable agent skills | Offer to install, ask first |

## Workflows

> Typical tasks with the Context Atlas MCP server, from detecting a project's stack to fetching a vendor's llms.txt.

Each workflow starts with a prompt you can paste as is. The steps show what a well-behaved agent does with it, so you can tell when it skips one.

### Detect a project's stack and load the docs

```text
Use contextatlas to detect the stack of this repository. Tell me what you found and which file proves it, then load the matching sources and follow their conventions.
```

1. The agent reads `package.json` (and every workspace `package.json` in a monorepo), the lockfile and config files such as `vercel.json`, `wrangler.jsonc` or `drizzle.config.ts`.
2. It calls `search` for each dependency or file it is unsure about, for example `search("drizzle.config.ts")`. A match on a topic's signals means the topic is part of the stack.
3. It reports the stack: each tool with the file that proves it, and anything the catalog does not cover.
4. It calls `get_topic` for each detected tool and fetches the `llms` or `rules` source first, then only the docs pages the task needs.
5. If a topic has an MCP server, skill or CLI, it lists them and asks before installing anything.

Add the prompt to your project's `AGENTS.md` or `CLAUDE.md` if every session should start this way.

### Fetch a vendor's llms.txt

```text
Get the llms.txt for Supabase from contextatlas and use it to answer: how do I enable row level security?
```

1. `search("supabase", kind: "llms")` or `get_topic("supabase")` returns the vendor's llms.txt URL, here `https://supabase.com/llms.txt`.
2. The agent fetches that URL, follows the links in it to the relevant pages and answers from them.

If you only need the links, the topic file works without MCP too: [/llms/supabase.txt](https://contextatlas.dev/llms/supabase.txt) lists every Supabase source as plain text.

### Find a vendor's MCP server or skills

```text
Does Neon have an MCP server or agent skills? Use contextatlas, and ask me before you install anything.
```

The agent calls `search("neon", kind: "mcp")` and `search("neon", kind: "skill")`, shows you what exists and waits for your answer. To connect a vendor's MCP server, it follows the instructions on the linked page.

### Propose a stack for a new project

```text
Use contextatlas to propose a stack for a booking app for a small climbing gym, with payments and a staff dashboard. One tool per role, with trade-offs. Wait for my approval before setting anything up.
```

1. The agent asks about anything the description leaves open: traffic, budget, where it should run.
2. It calls `list_topics` (optionally per region, such as `cloud` or `frameworks`) and groups the tools by role, then reads the sources of the candidates with `get_topic`.
3. It proposes one tool per role (hosting, framework, database, auth, payments) and names a close alternative where there is one.
4. After you agree, it calls `get_topic` for each chosen tool and sets the project up with the vendors' own CLIs and conventions.

### Check what changed in the catalog

Every answer contains `updatedAt`, the date of the last catalog change. Ask "When was contextatlas last updated?" to see whether your agent is working from current data.

## Troubleshooting

> What to do when the MCP server does not connect, times out or returns errors.

Start with the terminal check. It takes your agent and its config out of the picture:

```bash
curl -sS -m 10 https://contextatlas.dev/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

If this lists `search`, `get_topic` and `list_topics`, the server works and the problem is in the client config. If it fails, the problem is the network or the server.

### The client cannot connect

- **Wrong URL.** The URL is exactly `https://contextatlas.dev/mcp`: `https`, no trailing slash, no `/sse` and no `/mcp/` at the end. `https://contextatlas.dev/mcp/` returns 404.
- **Wrong transport.** The server speaks Streamable HTTP only. In configs, use the type `http` (Claude Code, VS Code), `streamable-http` or `remote`, not `sse`. A client that only supports SSE needs the [stdio bridge](https://contextatlas.dev/docs/mcp#clients-with-stdio-only).
- **Wrong config key.** Clients name the URL field differently: `url` (Claude Code, Cursor, Codex, VS Code), `httpUrl` (Gemini CLI), `serverUrl` (Windsurf). See [Connect a client](https://contextatlas.dev/docs/mcp#connect-a-client).
- **Config not reloaded.** Most clients read MCP config only at startup. Start a new session or restart the client after editing it.
- **Wrong scope.** In Claude Code, a server added without `--scope` only exists in the directory where you ran the command. Run `claude mcp list` from your project, or add it again with `--scope user`.

### Error messages

| You see | Meaning | Fix |
| --- | --- | --- |
| `405` and `Method not allowed.` | A GET request, for example from opening the URL in a browser | Expected. The server only answers POST from an MCP client |
| `406` and `Not Acceptable` | The request did not accept both `application/json` and `text/event-stream` | Use an MCP client, or send both in the `accept` header |
| `404` with an HTML page | Wrong path | Use `/mcp` exactly |
| `Unknown topic "…"` | `get_topic` with an id that does not exist | Let the agent use `search` or `list_topics` to find the id |
| `search` returns no results | Every word must match | Use fewer or shorter words, such as `database` instead of `serverless database hosting` |

### Timeouts

The tools answer from memory and usually respond in well under a second.

- Check that the site is up: `curl -sS -m 10 https://contextatlas.dev/healthz` returns `{"ok":true,…}`.
- Behind a company proxy or VPN, the client may not be allowed to reach external hosts. Try the curl check from the same machine and network as the client.
- Sandboxed agents (for example Codex with network access disabled) cannot reach any remote MCP server. Allow network access for the session, or use the files in [Give it to your agent](https://contextatlas.dev/docs/agents) instead.

### Still stuck

Open an issue on [GitHub](https://github.com/levin-staudt/contextatlas/issues) with your client, its config (without secrets) and the output of the curl check.

## Submitting data

> The planned write access to the MCP server for adding and updating catalog entries, with tokens and a review queue.

> **Planned.** Write access does not exist yet; it is tracked in [issue #19](https://github.com/levin-staudt/contextatlas/issues/19). Until it ships, add sources with a pull request as described in [Contributing](https://contextatlas.dev/docs/contributing).

The public server at `/mcp` is read-only and stays that way: no login, no key. Adding data will go through a separate, secured endpoint.

### How it will work

- **Separate endpoint.** A second MCP server, such as `/mcp/admin`, next to the public one.
- **Token.** Every request carries a bearer token. Tokens are issued and revoked by the maintainers and stored only as a hash. Requests without a valid token are rejected with 401 or 403.
- **Write tools.** Tools such as `add_topic`, `update_topic`, `add_source` and `propose_change`. Input is checked against the same schema as the catalog itself, so a malformed entry is rejected before review.
- **Review first.** New entries land in a review queue and go live only after a maintainer accepts them.
- **Audit log and rate limit.** Every change is recorded with token and time, and each token has a rate limit.

These docs will describe how to request a token, connect the endpoint and follow a submission through review once it is available.

## Site map

> Every page and file on contextatlas.dev, what it is for and who it is for.

Context Atlas has a few pages for people and several plain files for agents. Both show the same catalog.

### Pages

| Page | What it is |
| --- | --- |
| [/](https://contextatlas.dev/) | The atlas: every tool and source, grouped by region, with search and filters. Each tool has an anchor, such as [/#vercel](https://contextatlas.dev/#vercel) |
| [/agent](https://contextatlas.dev/agent) | The one-sentence prompt that hands the catalog to any agent, and the MCP command |
| [/docs](https://contextatlas.dev/docs) | These docs |

Filters on the atlas are part of the URL, so a filtered view can be shared, for example [/?q=database](https://contextatlas.dev/?q=database). Press ⌘K (Ctrl K) or `/` on any page to jump to a tool, a docs page or a section.

### Files for agents

| File | What it is |
| --- | --- |
| [/llms.txt](https://contextatlas.dev/llms.txt) | The whole catalog as Markdown, with instructions for agents. Start here |
| `/llms/<id>.txt` | One tool as a small llms.txt, for example [/llms/vercel.txt](https://contextatlas.dev/llms/vercel.txt) |
| [/llms-full.txt](https://contextatlas.dev/llms-full.txt) | llms.txt followed by every docs page, in one file |
| [/atlas.json](https://contextatlas.dev/atlas.json) | The catalog as JSON, grouped by region |
| `/docs/<page>.md` | Any docs page as Markdown, for example [/docs/mcp.md](https://contextatlas.dev/docs/mcp.md) |
| `/mcp` | The [MCP server](https://contextatlas.dev/docs/mcp) |
| `/api/…` | The [JSON API](https://contextatlas.dev/docs/api) |
| [/sitemap.xml](https://contextatlas.dev/sitemap.xml) | Every URL above, with the date of the last change |

All of these are public, need no key and allow requests from any origin (CORS).

### How the catalog is organized

- **Regions** group tools: Cloud providers (`cloud`), Frameworks (`frameworks`), Standards (`standards`) and CLIs (`clis`).
- **Topics** are the tools themselves, such as Vercel, Next.js or Drizzle. Each has an id used in every URL and tool call.
- **Sources** are the links a topic's vendor publishes for agents, each with a kind such as llms.txt or MCP server.
- **Signals** are files, dependencies and environment variables that show a project uses the topic.

[Reading a topic](https://contextatlas.dev/docs/topics) explains each of these in detail.

### How fresh it is

Every file carries the date of the last catalog change (`Last updated` in llms.txt, `updatedAt` in JSON and MCP answers). The catalog is maintained in the [GitHub repository](https://github.com/levin-staudt/contextatlas) and deployed on every change.

## Reading a topic

> How to find and filter tools on the home page, and what each line of a topic means.

### Find a topic

The [home page](https://contextatlas.dev/) lists every topic, grouped by region.

- **Search.** Type into "Search the atlas" to filter as you type. It matches names, roles, regions, detection signals and source titles and URLs, so `database`, `auth` or `turbo.json` all work. The search is kept in the URL, as in [/?q=database](https://contextatlas.dev/?q=database), so you can share it.
- **Filter by kind.** The legend lists the source kinds. Click a symbol to hide that kind of source, for example to see only MCP servers.
- **Jump to a region.** The region links take you to Cloud providers, Frameworks, Standards or CLIs.
- **Link to a topic.** Every topic has an anchor with its id, such as [/#supabase](https://contextatlas.dev/#supabase).

Without JavaScript the page shows everything; search and filters are added on top.

### What a topic shows

Take Neon as an example:

- **Name and role:** "Neon", "Postgres database". The role is the job the tool does in a stack, and for databases the engine.
- **Sources:** the links Neon publishes for agents, each marked with its kind.

The detection signals do not show on the page, but they are in every agent file. For Neon, they are the `@neondatabase/serverless` dependency and a `DATABASE_URL` that points to `*.neon.tech`.

### Source kinds

| Kind | What it is | How to use it |
| --- | --- | --- |
| llms.txt | A machine-readable index of the vendor's docs | Give it to your agent first |
| Full text | All docs in one file, often several megabytes | Let the agent search it; too large to read whole |
| Docs | Full documentation or reference | Read the parts you need |
| MCP server | Tools an agent can call directly, such as deploying or querying a database | Connect it to your agent |
| Agent skill | Installable instructions for agents | Install it in your agent |
| Rules | Prompts and rule files to paste into an agent | Add them to your agent's rules |
| Guide | How to work with agents on this platform | Read before you start |

### Signals

Signals tell an agent that a project uses a topic. There are four types:

- **File:** a path or glob relative to the repo root or a workspace package. A trailing `/` means a directory, as in `supabase/`; `**/` matches at any depth.
- **Dependency:** a package name in `package.json`. `*` matches any part, as in `@vercel/*`.
- **Env:** an environment variable name, such as `OPENAI_API_KEY`, found in `.env` files, CI config or code.
- **Hint:** a plain-language clue that cannot be checked mechanically.

### Everything in one place for one topic

Each topic has a small file with all of the above: `/llms/<id>.txt`, for example [/llms/neon.txt](https://contextatlas.dev/llms/neon.txt). It is the quickest way to hand one tool's sources to an agent.

## Give it to your agent

> Three ways to hand content from Context Atlas to a coding agent - a prompt, a link or Markdown - and when to use each.

### The prompt from /agent

[/agent](https://contextatlas.dev/agent) has one sentence to paste into Claude Code, Codex, Cursor or any agent with web access. Pick the mode first:

- **I have a project:** run it inside your repository. The agent detects the stack, tells you what it found, then loads the matching sources.
- **I'm starting something new:** describe what you want to build. The agent proposes a stack, explains the trade-offs and sets it up once you agree.

The prompt only points to [/llms.txt](https://contextatlas.dev/llms.txt). The real instructions live there, so they stay current without you changing the prompt.

```text
Read https://contextatlas.dev/llms.txt and follow its instructions for an existing project: detect the stack of this repository, tell me what you found, then load the matching sources and follow their best practices.
```

### Links

Agents fetch plain-text URLs reliably. Paste a link into the chat, or put it in your project's `AGENTS.md` or `CLAUDE.md` so every session sees it.

| To give the agent… | Paste |
| --- | --- |
| The whole catalog with instructions | `https://contextatlas.dev/llms.txt` |
| The sources of one tool | `https://contextatlas.dev/llms/<id>.txt`, such as `https://contextatlas.dev/llms/stripe.txt` |
| The catalog and all docs at once | `https://contextatlas.dev/llms-full.txt` |
| One docs page | The page URL with `.md`, such as `https://contextatlas.dev/docs/mcp.md` |
| Structured data for a script | `https://contextatlas.dev/atlas.json` or the [JSON API](https://contextatlas.dev/docs/api) |

Prefer the topic files over the whole catalog when you know your stack. They are small and leave room in the context for the vendor docs themselves.

A line for `AGENTS.md`:

```markdown
Before working with a tool from our stack, fetch its sources from https://contextatlas.dev/llms/<id>.txt (ids: nextjs, drizzle, vercel) and follow them.
```

### Markdown

Every docs page has a Markdown version: add `.md` to its URL, or use the link at the bottom of the page. Every docs page also announces it with `<link rel="alternate" type="text/markdown">`, so agents that read a page's head find it on their own.

### MCP instead

If your agent supports MCP, connecting the [MCP server](https://contextatlas.dev/docs/mcp) is usually better than links: the agent searches and fetches only what it needs, without you choosing files.

## JSON API

> Read the catalog over HTTP with /api/topics, /api/topics/:id and /api/search. No key needed.

The API returns the same data as the MCP tools, as JSON. It needs no key and allows requests from any origin.

### GET /api/topics

Every topic with its region, signals and sources.

```bash
curl -s https://contextatlas.dev/api/topics
```

```json
{
  "updatedAt": "2026-10-23",
  "topics": [
    {
      "id": "vercel",
      "name": "Vercel",
      "role": "Hosting",
      "signals": [{ "type": "file", "pattern": "vercel.json" }],
      "sources": [{ "kind": "mcp", "title": "Vercel MCP server", "url": "https://vercel.com/docs/mcp/vercel-mcp" }],
      "region": { "id": "cloud", "name": "Cloud providers" }
    }
  ]
}
```

### GET /api/topics/:id

One topic by id.

```bash
curl -s https://contextatlas.dev/api/topics/hono
```

Returns `{ "updatedAt": "…", "topic": { … } }`. An unknown id returns 404 with an `error` message.

### GET /api/search

Full-text search, the same as the MCP tool `search`. Every word must match, as a prefix.

| Parameter | Type | Description |
| --- | --- | --- |
| `q` | required, 1 to 200 characters | Words to search for |
| `kind` | optional | `llms`, `full`, `docs`, `mcp`, `skill`, `rules` or `guide` |
| `limit` | optional, 1 to 50 | Maximum number of topics, default 10 |

```bash
curl -s 'https://contextatlas.dev/api/search?q=vercel&kind=mcp&limit=2'
```

```json
{
  "query": "vercel",
  "results": [
    {
      "topic": { "id": "vercel", "name": "Vercel", "role": "Hosting" },
      "sources": [{ "kind": "mcp", "title": "Vercel MCP server", "url": "https://vercel.com/docs/mcp/vercel-mcp" }],
      "score": -6.1
    }
  ]
}
```

Invalid parameters return 400 with an `error` message that names the parameter.

### Caching

Responses carry `Cache-Control` headers: topics for an hour in the browser and a day at the CDN, search results for five minutes. The catalog changes only with a deploy, so there is no need to poll.

### Other formats

- [/atlas.json](https://contextatlas.dev/atlas.json): the whole catalog in one file, grouped by region, with each topic's `llmsTxt` URL
- [/llms.txt](https://contextatlas.dev/llms.txt) and `/llms/<id>.txt`: the same data as Markdown for agents

### Typed client

The API is a [Hono](https://hono.dev) app, and its route types are exported as `AppType`. TypeScript projects in this repository can use the typed client:

```ts
import type { AppType } from "@contextatlas/server";
import { hc } from "hono/client";

const api = hc<AppType>("https://contextatlas.dev");
const res = await api.api.topics[":id"].$get({ param: { id: "cloudflare" } });
```

## CLI

> The planned contextatlas command-line client, for searching the catalog and detecting a project's stack from the terminal.

> **Planned.** The CLI does not exist yet; it is tracked in [issue #13](https://github.com/levin-staudt/contextatlas/issues/13). Until then, use the [MCP server](https://contextatlas.dev/docs/mcp) or the [JSON API](https://contextatlas.dev/docs/api) with curl.

`contextatlas` will bring the catalog to the terminal, for agents in clients without MCP support and for scripts.

### Planned commands

| Command | What it will do |
| --- | --- |
| `contextatlas search <query>` | Search tools and sources, like the MCP tool `search` |
| `contextatlas topic <id>` | Show all sources of one tool |
| `contextatlas detect` | Scan the current project for the catalog's signals (files, dependencies, also in workspace packages) and list the matching sources |
| `contextatlas mcp` | Run the MCP server over stdio, for clients that only start local servers |

Every command will take `--json`, so agents can parse the output reliably.

### Until then

The same answers are one curl away:

```bash
# search
curl -s 'https://contextatlas.dev/api/search?q=database'

# one tool
curl -s https://contextatlas.dev/llms/drizzle.txt
```

For stdio-only clients, the [mcp-remote bridge](https://contextatlas.dev/docs/mcp#clients-with-stdio-only) works today.

## Contributing

> Add a vendor, tool or source to Context Atlas with a pull request, or add a docs page.

Context Atlas lives in [one GitHub repository](https://github.com/levin-staudt/contextatlas). Every change is a pull request, and every merge to `main` is deployed.

### Add a vendor or source

The whole catalog is one file: `packages/core/src/catalog.ts`.

1. Find the sources the vendor publishes for agents and check that each URL works. Look for, in this order: `/llms.txt`, `/llms-full.txt`, an MCP server (docs page and GitHub repo), agent skills, AI rules or prompt pages, an AI or agents guide, and the CLI reference. Only add links published by the vendor or its official GitHub organization.
2. Edit `packages/core/src/catalog.ts`:
   - For an existing tool, add a source (`kind`, `title`, `url`) to its `sources`.
   - For a new tool, add a topic to the right region (`cloud`, `frameworks`, `standards` or `clis`), with an `id` (lowercase slug), a name, a short `role` and detection `signals`.
   - Add signals so agents can detect the tool in a repo: `file("fly.toml")`, `dep("@vercel/*")`, `env("OPENAI_API_KEY")` or, for anything else, `hint("…")`. Prefer files and dependencies over hints.
3. Set `updatedAt` at the top of the file to today's date.
4. Run `bun run check`. The tests reject duplicate ids or URLs, links that are not https and malformed signals.
5. Open a pull request.

Working with an agent? The repository includes an `add-source` skill with these steps. Ask it to "add Fly.io to Context Atlas".

### Preview your change

```bash
bun install
bun dev
```

The site runs at `http://localhost:3000` and reloads when you edit the catalog. Check your topic with `curl -s localhost:3000/llms/<id>.txt` and `curl -s 'localhost:3000/api/search?q=<name>'`.

### Add or change a docs page

The docs are MDX files in `packages/core/docs/`. A new page is one new file:

```mdx
---
title: My page
description: One sentence for search results, link previews and llms.txt.
section: Reference
order: 130
updatedAt: 2026-10-23
---

Write Markdown here. Link other pages as [MCP server](/docs/mcp).
```

- `section` groups pages in the sidebar; sections appear in the order of their first page.
- `order` sorts pages, lowest first.
- `updatedAt` is the date of the last change, used in the sitemap. Bump it whenever you edit the page.
- The file name is the URL: `my-page.mdx` becomes `/docs/my-page` and `/docs/my-page.md`, and is added to the sidebar, `/llms.txt`, `/llms-full.txt` and the sitemap.
- Write absolute links to the site as `https://contextatlas.dev/…`; they follow the server's `SITE_URL`.
- Text in curly braces and angle brackets is read as code by MDX. Put it in backticks.

Run `bun run check`: it fails on missing or invalid frontmatter and on links to docs pages that do not exist.