MCP client
Claude CodeCursoragent shell
Learn
What is an MCP server?
An MCP server is a small service that exposes tools, resources, and reusable prompts to AI agents through the Model Context Protocol. Instead of every agent integrating with every system in a different way, MCP gives agents a standard interface for reaching external context and capabilities.
Short answer
An MCP server is a standard way to give an AI agent access to external context and tools.
AI agents are more useful when they can reach information outside the chat: files, documentation, databases, APIs, issue trackers, plans, and project-specific knowledge. An MCP server exposes that outside world in a structured way. The agent connects as an MCP client, discovers what the server offers, and uses those tools or resources during the task.
MCP does not make the agent smarter by itself. It gives the agent a cleaner, more consistent way to access the things it needs.
Basics
The client is the agent side. The server is the capability side.
In an MCP setup, the AI application or coding agent acts as the MCP client. The MCP server is the service that exposes capabilities. For example, a coding agent may connect to one MCP server for project documentation, another for GitHub issues, and another for database inspection.
MCP client
The AI application or agent environment that wants to use external context or tools. Examples: a coding agent, desktop assistant, or IDE-integrated AI tool.
MCP server
The service that exposes external capabilities to the client. Examples: documentation access, file search, database queries, project memory, issue tracking, or deployment tools.
The agent asks. The MCP server exposes what the agent is allowed to use.
Primitives
MCP servers usually expose tools, resources, and prompts.
Different MCP servers expose different capabilities, but the mental model is simple: a server can let the agent do something, read something, or reuse a structured instruction.
Tools let agents act. Resources give agents context. Prompts shape how agents perform repeatable work.
The problem
Without a standard protocol, every agent integration is custom.
AI agents need to work with many systems: repositories, docs, databases, issue trackers, cloud tools, and internal APIs. Without a standard interface, every agent and every tool needs a separate integration. MCP gives tool builders and agent builders a shared pattern for connecting agents to the outside world.
Custom integrations multiply.
Each tool has to support each agent in a different way.
Context is hard to expose safely.
Teams need deliberate control over what an agent can see or do.
Agents start under-informed.
Without external context, agents depend on whatever the user pasted into the prompt.
Workflows become fragmented.
Docs, tickets, plans, and code live behind separate doors.
MCP is useful because agents need a standard way to reach the systems where work actually lives.
Coding agents
Coding agents need project context before they edit code.
A coding agent can write code, but it also needs to understand the surrounding project: architecture, requirements, APIs, data models, plans, decisions, and current work. MCP gives coding agents a structured way to reach that context and use tools that support the development workflow.
Read project documentation.
Specs, diagrams, architecture notes, contracts, and decisions.
Inspect development systems.
Issues, pull requests, logs, databases, deployments, or test output.
Run workflow actions.
Create tasks, update docs, record execution notes, or call internal tools.
Share context across agents.
Multiple MCP-aware agents can connect to the same source of truth instead of each tool inventing its own memory.
For coding agents, MCP is most valuable when it connects the agent to the real project context before implementation starts.
Examples
Common kinds of MCP servers.
MCP servers can be built for many systems. The important question is what capability the server exposes and whether the agent should be allowed to use it for the current task.
- Filesystem or repository servers — expose project files and codebase search.
- Documentation servers — expose internal docs, product notes, API references, or design artifacts.
- Database servers — let agents inspect schemas or query approved data.
- Issue tracker servers — expose tickets, bug reports, feature requests, and project status.
- Observability servers — expose logs, traces, metrics, or deployment status.
- Memory servers — expose durable context such as specs, decisions, plans, and execution history.
Windy fits into the memory-server category: it exposes a project's design and execution memory to coding agents over MCP.
Control
MCP servers should be deliberately scoped.
Giving an agent access to external systems is powerful, so access should be intentional. A useful MCP setup makes it clear which servers are connected, what each server exposes, and what the agent is allowed to read or do.
- Connect only what the task needs. More access is not always better.
- Scope by project or workspace. The agent should see the relevant context, not everything by default.
- Prefer reviewable actions. Important writes should be visible and auditable.
- Revoke access when needed. Teams should be able to disconnect servers or rotate credentials.
- Keep humans in the loop. MCP gives agents capabilities; it does not remove developer responsibility.
The best MCP setup gives agents enough context to help, but not so much access that the workflow becomes hard to trust.
Comparison
MCP is not just another API.
An API is usually designed for application-to-application integration. MCP is designed for AI agents that need to discover and use tools and context during a task. A system may expose an API for normal product behavior and an MCP server for agent-facing workflows.
| Interface | Designed for | Typical use |
|---|---|---|
| REST / GraphQL API | Application integrations | Product features, backend services, external apps |
| SDK | Developers writing code | Typed integration with a service |
| MCP server | AI agents using context and tools | Agent workflows, tool calls, resource access, memory |
MCP is the agent-facing interface. It is the door the AI agent uses while doing work.
Windy
Windy exposes project memory to coding agents over MCP.
Windy is the shared memory layer for coding agents. It gives each project one source of truth for specs, architecture, diagrams, contracts, decisions, plans, tasks, and execution history. Humans review and shape that memory in the web app. Coding agents read and write it through a project-scoped MCP endpoint.
Windy Docs — the design memory
Specs, architecture notes, diagrams, contracts, schemas, requirements, and decisions.
Windy Plans — the execution memory
Ordered tasks, objectives, dependencies, acceptance criteria, prompts, and execution logs.
Your coding agent still writes the code. Windy gives it an MCP-accessible source of truth to build from.
In practice
What this looks like with a coding agent.
A developer wants a coding agent to implement a new export feature for a SaaS product.
Without MCP
The developer pastes a prompt, attaches a few files, and manually explains the feature, API shape, permissions, data model, and rollout concerns.
With MCP servers
- The coding agent reads project specs from a documentation or memory server.
- It checks the relevant issue or task from a project-management server.
- It inspects approved schema or API context from another server.
- It uses the current plan and acceptance criteria before editing code.
- It writes back execution notes or documentation updates where allowed.
MCP does not replace the developer. It reduces the amount of context the developer has to manually reconstruct for every run.
Pitfalls
Common mistakes when thinking about MCP servers.
Thinking MCP is the model.
MCP is a protocol. It connects agents to external tools and context; it is not the AI model itself.
Connecting everything by default.
More servers can mean more risk and more irrelevant context. Scope matters.
Confusing tools with memory.
A tool server lets the agent act. A memory server gives the agent durable context.
Skipping human review.
MCP can let agents write to systems, but important changes still need review.
Treating MCP as only developer tooling.
MCP is especially useful for coding agents, but the pattern can apply anywhere agents need external context and tools.
FAQ
Questions, answered.
An MCP server is a service that exposes tools, resources, or prompts to AI agents through the Model Context Protocol.
The MCP client is the agent-side application that connects to MCP servers. A coding agent or AI assistant can act as an MCP client.
It can expose actions the agent can call, resources the agent can read, and reusable prompts the agent can use during a workflow.
No, but coding agents are one of the clearest use cases because they need access to project files, docs, plans, issues, and other development context.
No. APIs are general integration interfaces. MCP servers are designed specifically to expose capabilities to AI agents in a discoverable, agent-friendly way.
An MCP memory server is a server that exposes durable context, such as project specs, decisions, plans, and execution history. For a deeper explanation, see MCP memory server.
Windy exposes project Docs and Plans over a project-scoped MCP endpoint so coding agents can read and write the source of truth before and after implementation.
Related
Keep exploring.
Your coding agent still writes the code. Windy gives it an MCP-accessible source of truth to build from.
Windy fits into the memory-server category: it exposes a project's design and execution memory to coding agents over MCP.
windylogic.ai