Using MCP to Power Up GitHub Copilot

Learn how to integrate the Model Context Protocol (MCP) with GitHub Copilot to automate tasks, improve context handling, and boost daily productivity.

What is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard introduced by Anthropic in 2024. It’s designed to connect language models—like GitHub Copilot—to external tools and data sources efficiently. This makes such connections more consistent and scalable within the development environment.

Since I started using MCP, I’ve noticed a significant boost in my productivity. It has helped me reduce repetitive prompts and automate several tasks that previously required manual effort. In this article, I’ll share two MCP servers I use frequently that have made a real difference in my daily workflow.

Why It Matters

Before MCP, connecting language models to external tools required custom solutions, which made maintenance more complex. With MCP, Copilot can access external data in a structured way, simplifying the process and improving performance.

Practical Examples: Task Manager and Sequential Thinking

Task Manager

The mcp-taskmanager server allows Copilot to manage tasks in an organized way. It operates in two main steps:

• Planning: It receives a list of tasks, organizes them into an internal queue, and returns an execution plan with unique IDs for each task.
• Execution: It provides the next task in the queue when requested and allows tasks to be marked as completed, removing them from the list.

This is especially useful for automating repetitive work and tracking progress in development projects.

Sequential Thinking

The sequentialthinking server helps Copilot maintain a logical, step-by-step thought process. It allows you to:

• Break down complex problems into manageable steps;
• Review and refine ideas as your understanding deepens;
• Explore alternative reasoning paths;
• Dynamically adjust the number of thoughts;
• Generate and validate solution hypotheses.

It’s ideal for projects with multiple phases or decision-making chains.

How I’ve Been Using It

By using taskmanager and sequentialthinking together, I’ve noticed that Copilot can organize its thought process much more effectively. When I provide a broader prompt, it breaks it down into smaller tasks and processes them one by one. After completing each step, it asks whether it should move on or if I’d like to review or make changes — giving me control and keeping the process flexible.

This has been especially helpful for repetitive or mentally draining tasks like writing unit tests, building mocks, or making mechanical updates across the codebase. Now I can stay focused and review things more easily.

How to Configure It in VS Code

You can set up MCP servers directly in the settings.json file in VS Code. This allows you to define each server as a ready-to-run command via npx, making them easier to use across different projects.

Here’s an example:

"mcp": {
"inputs": [],
"servers": {
"Sequential Thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"taskmanager": {
"command": "npx",
"args": ["-y", "@kazuph/mcp-taskmanager"]
}
}
}

With this setup, VS Code can automatically start the servers when you open the project—no manual steps needed.

In addition to using MCPs, you can also fine-tune Copilot’s behavior by adding a custom instruction file. Simply create a file named copilot-instructions.md inside the .github folder at the root of your project. This file acts as a style guide or rulebook for how Copilot should suggest code.

To enable it, add the following setting to your settings.json file:

"github.copilot.chat.codeGeneration.useInstructionFiles": true

Another helpful option is the following test-specific setting:

"github.copilot.chat.testGeneration.instructions"

It’s designed for automated test generation. You can use it to guide Copilot in following best practices defined by your team or coding style, which helps reduce hallucinations, unnecessary test cases, and unhelpful suggestions.

Is It Worth It?

GitHub Copilot already offers a solid experience for code suggestions. With MCP, it becomes even smarter—capable of pulling in external information, automating tasks, and maintaining a clearer thought process.

More than just a minor upgrade, MCP opens the door to a new way of working with AI in software development. Tools like taskmanager and sequentialthinking show how ideas can be more effectively structured, tasks more logically divided, and workflows easier to follow.

For dev teams, these integrations help you stay focused on what really matters and distribute work more efficiently. You don’t need fancy infrastructure to get started—the setup is simple, and even small projects can benefit.

It’s definitely worth trying out. With just a bit of setup, you’ll quickly notice the everyday benefits. And the sooner you start, the better prepared you’ll be for what’s coming next in AI-powered development.