diff --git a/articles/mcp-server-for-code.md b/articles/mcp-server-for-code.md
new file mode 100644
index 0000000..011b59e
--- /dev/null
+++ b/articles/mcp-server-for-code.md
@@ -0,0 +1,161 @@
+---
+title: "MCP Server for Code: Setup Guide and Best Practices"
+description: "Learn how to set up an MCP server for code, choose the right transport, and follow best practices to give AI coding agents structured tool access."
+date: 2026-10-15
+image: ./mcp-server-for-code.png
+imageAlt: "Diagram showing an MCP server for code linking an AI coding agent to GitHub, a database, and a browser via MCP"
+ogTitle: "MCP Server for Code: The Complete Setup Guide and Best Practices"
+ogDescription: "Discover how an MCP server for code connects AI coding agents to repos, databases, and tools. Follow this setup guide to configure servers correctly and avoid common pitfalls."
+---
+
+# MCP Server for Code: Setup Guide and Best Practices
+
+An MCP server for code is a lightweight process that gives AI coding agents structured access to repositories, databases, browsers, and internal tools via the Model Context Protocol. You install one per capability, point your IDE or terminal agent at it, and the agent can read, query, or act on that resource without leaving its context window.
+
+## What Is an MCP Server and Why Does It Matter for Coding?
+
+MCP stands for Model Context Protocol, an open standard that lets AI coding agents talk to external tools through a consistent interface. Instead of each agent building its own custom integration for GitHub, a database, or a browser, every tool exposes itself as an MCP server and every agent speaks the same protocol.
+
+MCP has three layers: the **host** (your IDE, such as VS Code or Cursor), the **client** (the protocol handler inside that host), and the **server** (the separate process that wraps the external tool and exposes it as callable actions).
+
+Because the server handles the interface, the agent sends a targeted query and gets back only the data it asked for. A query like "list open PRs for this repo" returns a structured list, not a raw API dump that would consume hundreds of tokens.
+
+The ecosystem has grown quickly. As of October 2026, more than 3,017 MCP servers are listed specifically for developer tools in the official registry. A separate curated directory lists 1,536 servers under the Code and Development category alone. The [official GitHub MCP server](https://github.com/github/github-mcp-server/) has crossed 33,449 stars on its repository, which signals how fast adoption has moved among working developers.
+
+That growth also means quality varies. Picking the right servers and configuring them correctly matters more than installing as many as possible.
+
+## Local vs. Remote MCP Servers: Which Transport Should You Use?
+
+MCP servers communicate with the host over one of two transport types: **stdio** (local) or **HTTP with SSE** (remote). The choice affects security, setup complexity, and what the server can access.
+
+A **stdio server** runs as a child process on your machine. The host launches it, communicates over standard input and output, and kills it when the session ends. All data stays local. This is the right choice when the server needs access to your filesystem, a local database, or any resource that should not leave your machine.
+
+A **remote HTTP server** runs on the internet or your internal network and accepts connections over HTTP with server-sent events. Your agent authenticates, sends requests, and receives responses over the wire. Use this for cloud-hosted tools like GitHub, documentation services, or any resource that is already remote by nature.
+
+Here is a quick comparison to help you decide:
+
+| Server | Transport | Runs on | Primary use case |
+|---|---|---|---|
+| GitHub MCP Server | HTTP (remote) | Cloud | Repository management, PR review, CI/CD monitoring |
+| Filesystem MCP | stdio (local) | Desktop app | Scoped read/write access to local directories |
+| Postgres MCP Pro | stdio (local) | Desktop app | Schema inspection, queries, EXPLAIN analysis |
+| Playwright MCP | stdio (local) | Desktop app | Browser automation, UI testing, screenshots |
+| Context7 | HTTP (remote) | Cloud | Version-specific library documentation |
+
+One more distinction worth understanding: native IDE code execution versus MCP-based sandboxed execution. When your IDE runs code directly, it has full access to your environment, your secrets, and your filesystem. When an agent executes code through an MCP server, the server defines the boundary. A Playwright MCP server can drive a browser without giving the agent shell access. A Filesystem MCP server can read only the directories you explicitly pass as arguments during configuration. That scoping is the main reason to prefer MCP-based execution for anything sensitive.
+
+Remote servers add OAuth or token-based authentication to that picture. The GitHub MCP Server offers a remote endpoint with OAuth, so you get zero-install setup with credential management handled outside your local config.
+
+## How to Add an MCP Server to VS Code or Cursor
+
+Both VS Code (with Copilot Chat in agent mode) and Cursor read MCP configuration from a JSON file. The steps below cover both editors.
+
+1. **Create or open your MCP config file.** In VS Code, this lives at `.vscode/mcp.json` inside your project, or in your user settings. In Cursor, open Settings, navigate to the MCP section, and click "Add new MCP server" to edit the underlying JSON directly.
+
+2. **Add a server entry.** Each entry needs a name, a transport type, and either a command (for stdio) or a URL (for HTTP). A stdio entry for the Filesystem MCP requires Node.js installed and lists the allowed directory paths as arguments. A remote entry for the GitHub MCP Server needs the server URL and your OAuth token.
+
+3. **Enable remote GitHub MCP access in VS Code using the Copilot Chat agent mode.** Open the Copilot Chat panel, switch to agent mode, and VS Code will prompt you to authenticate with GitHub. Once authenticated, the GitHub MCP Server appears as an available tool set without any local install.
+
+4. **Verify the server is active.** In VS Code, the Copilot Chat agent mode shows connected servers in the tool picker. In Cursor, the MCP settings panel lists each server with a green or red status indicator. If a server shows as disconnected, check that the command path is correct and that any required runtime (Node.js for Filesystem MCP, Python with uv for Postgres MCP Pro) is installed.
+
+5. **Test with a simple query.** Ask your agent to list open pull requests (GitHub MCP Server) or read a specific file path (Filesystem MCP). A successful response confirms the transport is working. An error at this stage almost always points to a missing runtime, a wrong path in the config, or an expired token.
+
+## Best MCP Servers for Code: A Practical List
+
+Five servers cover most coding workflows. Each one handles a distinct capability, and running them together gives your agent structured access to repositories, local files, databases, browsers, and documentation without overloading its context window.
+
+According to [Cursor's 2026 report](https://cursor.com/guides/coding-agent-mcp), average tool calls per session for coding agents increased by roughly 30% over a two-month period. That growth makes server selection more consequential: the more tools an agent can call, the more important it is that each one is scoped tightly and does one job well.
+
+**GitHub MCP Server**
+
+The GitHub MCP Server connects your agent to GitHub so it can read repositories, manage issues and pull requests, analyze code, and monitor CI/CD workflows. It runs in the cloud with a remote endpoint and OAuth, so there is nothing to install locally. If your organization blocks remote access, it can also run locally via Docker. The official GitHub MCP server has crossed 33,449 stars on its repository. Pricing is not publicly listed.
+
+**Filesystem MCP**
+
+Filesystem MCP gives your agent scoped read and write access to specific local directories outside its current working tree. You pass the allowed paths as arguments during configuration, and the server enforces those boundaries strictly. It requires Node.js. Use it when your agent needs to read config files, write generated output, or inspect parts of a monorepo that fall outside the active project root. Pricing is not publicly listed.
+
+**Postgres MCP Pro**
+
+Postgres MCP Pro lets your agent inspect database schemas, run queries, and analyze query performance using EXPLAIN. It requires Python with uv installed. Run it in restricted mode to grant read-only access, which prevents the agent from making unintended writes during exploratory queries. Use this server when your agent needs to understand data shape before generating migration scripts or query logic. Pricing is not publicly listed.
+
+**Playwright MCP**
+
+Playwright MCP drives a real web browser: it navigates pages, clicks elements, fills forms, and takes screenshots. It operates on accessibility snapshots by default, which keeps token usage lower than full-page captures. Pass the `--headless` flag to hide the browser window during automated runs. This server handles both UI testing and API verification workflows where you need to confirm what a browser actually renders, not just what an endpoint returns. If you work with Postman-style API testing or need to verify request and response flows in a browser context, Playwright MCP covers that use case directly. Pricing is not publicly listed.
+
+**Context7**
+
+Context7 pulls version-specific library documentation and delivers it to your agent on demand. It runs in the cloud, so there is nothing to configure locally beyond adding the server entry. When your agent generates code against a specific version of a framework, Context7 points it at the right API surface rather than methods from a different version. Pricing is not publicly listed.
+
+For teams asking about a Codex MCP server, no official standalone Codex MCP server exists as a named product. The capability, meaning AI-assisted code generation informed by repository context, is typically covered by combining the GitHub MCP Server with a code-graph tool rather than a single dedicated server.
+
+## Security and Performance Best Practices for MCP Servers
+
+The biggest risks with MCP servers are not the servers themselves. They are misconfigured permissions, secrets stored in plain text, and too many tools registered at once.
+
+**Manage secrets outside your config file.** Never put API tokens or database credentials directly in `mcp.json` or any config file that gets committed to version control. Use environment variables and reference them by name in your server configuration. For team environments, a secrets manager keeps credentials out of local files entirely.
+
+**Scope permissions to the minimum needed.** Filesystem MCP only accesses the paths you list as arguments. Postgres MCP Pro should run in restricted mode for any session where the agent is exploring rather than writing. The GitHub MCP Server uses OAuth scopes, so grant only the repository permissions your workflow actually requires. Every permission you do not grant is an action the agent cannot take by accident.
+
+**Avoid tool bloat.** Each registered server adds tools to the agent's available set. More tools mean the agent spends more of its context window reasoning about which tool to call, and the chance of an unintended action goes up. Register only the servers your current task needs. In VS Code and Cursor, you can enable and disable individual servers without removing their config entries.
+
+This matters more as agent sessions grow longer. Cursor reported that tool calls per session increased by approximately 30% over a two-month period. That is a directional trend from a single vendor report, not a universal benchmark, but it points to a real pattern: agents call more tools as sessions extend, which amplifies both the value and the risk of each registered server.
+
+**Use local transport for sensitive data.** Any server that touches your filesystem, a local database, or internal credentials should run over stdio, not HTTP. Local transport keeps data on your machine and eliminates the network as an attack surface.
+
+**Rotate tokens on a schedule.** OAuth tokens and API keys for remote servers like GitHub MCP Server and Context7 should rotate regularly. Set a reminder or automate rotation through your secrets manager. An expired token surfaces quickly as a connection error; a compromised one may not.
+
+## Can I Build My Own MCP Server for Internal Code Tools?
+
+A custom MCP server makes sense when no existing server covers your internal tooling. Common cases include a proprietary code review system, an internal documentation API, a deployment pipeline with a non-standard interface, or a legacy database that no public server supports.
+
+Before building, check whether an existing server covers the use case with configuration alone. Filesystem MCP handles many local file scenarios. Postgres MCP Pro covers most SQL databases. If your tool exposes an HTTP API, a thin wrapper may be enough.
+
+When a custom server is the right call, the implementation follows these steps:
+
+1. **Choose your transport.** Use stdio if the server will run locally and handle sensitive internal data. Use HTTP with SSE if it needs to be shared across a team or accessed remotely.
+2. **Define your tools.** Each tool is a named, callable action with a description and a typed input schema. Keep tool names specific: `get_deployment_status` is better than `check_thing`.
+3. **Register executable actions as tools within the server implementation.** Each registered action should do one thing. Avoid combining multiple side effects in a single tool call, since agents treat each tool as atomic.
+4. **Handle errors explicitly.** Return structured error responses rather than letting the server crash. Agents need a clear signal when a tool call fails so they can retry or report the issue rather than silently continuing with bad data.
+5. **Test each tool in isolation before connecting it to an agent.** Call the server directly with a test input and verify the output matches your schema. Connecting a broken server to a live agent session makes debugging harder.
+
+## When a Code Graph Gives AI Agents More Than File Access
+
+File-access servers give your agent the contents of a file. They do not tell it what calls that file, what tests cover it, or what breaks if you change a function signature. That gap is where code-graph tools come in.
+
+When an agent edits a function, the question that matters is not "what is in this file" but "what else does this change touch." A raw filesystem or repository server cannot answer that. It returns text. A code graph returns relationships: callers, callees, API boundaries, and the tests that exercise each path. That is the difference between knowing what code says and knowing what it does.
+
+[Memtrace](https://memtrace.io/) is a code-graph tool that builds and maintains a local graph connecting functions, callers, APIs, and tests across a repository. Your agent queries the graph before making edits to understand blast radius, trace execution paths, and recall why code was written a certain way. The graph stays current as the codebase changes, so the agent is not working from a stale snapshot.
+
+Memtrace connects to your existing coding tools via MCP, which means it slots into the same VS Code or Cursor setup this guide already covers. You do not replace your other servers. Add Memtrace alongside them, and your agent gains structural context that file access alone cannot provide.
+
+Pricing starts at free on the Community plan, which includes 1,000 graph queries per month and then 50 per day. The Pro plan runs $9/month for 5,000 queries with no daily throttle. Pro+ is $15/month for 20,000 queries. Teams is $29/seat/month with unlimited queries, a self-hosted MemDB, an organization workspace, and seat pool enforcement. Enterprise includes SSO, air-gapped MemDB, and deployment support at custom pricing.
+
+Prices and plan limits verified as of October 2026.
+
+## FAQs
+
+### How does the GitHub MCP server improve AI code generation?
+
+The GitHub MCP Server gives your agent direct access to repository history, open pull requests, issues, and CI/CD status. Instead of pasting context manually, the agent queries the server and gets structured answers. It can check whether a similar fix already exists in a PR, confirm a test passed in the last run, or read the issue description before writing a solution, all without leaving its context window.
+
+### Does VS Code support MCP servers natively or do I need an extension?
+
+VS Code supports MCP servers natively through Copilot Chat in agent mode, with no additional extension required. Add server entries to an `mcp.json` config file, switch Copilot Chat to agent mode, and VS Code handles the connection. Remote servers like the GitHub MCP Server use OAuth authentication that VS Code prompts you to complete the first time you activate agent mode.
+
+### How many MCP servers can I run at the same time without hurting performance?
+
+There is no hard limit, but running too many servers at once hurts agent quality before it hurts machine performance. Each registered server adds tools to the agent's available set, and the agent spends context reasoning about which tool to call. A practical ceiling is four to six servers for any given task. Disable servers you are not actively using rather than removing their config entries, so you can re-enable them quickly when the task changes.
+
+### What is the difference between a Postman MCP server and a Playwright MCP server for API testing?
+
+No official Postman MCP server exists as a named standalone product. For API testing through MCP, Playwright MCP is the practical option. It drives a real browser to navigate endpoints, fill forms, and capture responses, which covers both UI verification and request-level API testing in a single server. If your workflow is purely HTTP request and response without a browser, a custom MCP server wrapping your existing API client is a more direct fit.
+
+### Is there an official Codex MCP server, or do I need to build one?
+
+No official standalone Codex MCP server exists as a named product. The capability most teams associate with a Codex MCP server, meaning AI-assisted code generation informed by repository context, is typically covered by combining the GitHub MCP Server with a code-graph tool like Memtrace. That combination gives your agent both repository access and structural context, which is what most Codex-style workflows actually need.
+
+## Conclusion
+
+An MCP server for code is the extension layer that determines what your AI coding agent can actually see and do. Choosing the right transport, scoping permissions tightly, and picking servers that match your workflow gives the agent clean, structured access without overloading its context window or exposing credentials.
+
+Start by adding one or two servers that cover your most common tasks, verify each one works with a simple test query, and expand from there. If your work involves understanding how a change ripples across a codebase, add a code-graph server alongside your file-access and repository servers so the agent can answer structural questions, not just read file contents.
diff --git a/articles/mcp-server-for-code.png b/articles/mcp-server-for-code.png
new file mode 100644
index 0000000..44d577f
Binary files /dev/null and b/articles/mcp-server-for-code.png differ