GitHub MCP tool for interactive Copilot chat session (without PR creation)

[ganeshb24]

Hi team,

Is there a GitHub MCP tool (or API) that can open an interactive chat session with Copilot for codebase exploration — e.g., investigating features or debugging — without creating a PR?

Currently, the only programmatic option I'm aware of is assign_copilot_to_issue_with_intent, which assigns the coding agent to an issue. However, that workflow is:

• Asynchronous (no back-and-forth conversation)

• PR-centric (always creates a branch + PR)

What I'm looking for is a way to programmatically start a synchronous, conversational session with Copilot that has full codebase context — similar to Copilot Chat on github.com — but invokable via MCP/API.

Questions:

1. Does such a tool/API exist today?

2. If not, is this on the roadmap?

3. Are there alternative approaches to achieve interactive, read-only code Q&A programmatically?

Thanks!

[MrC8559]

There are really two separate pieces here now: the GitHub MCP server and the Copilot SDK.

The GitHub MCP server itself is a tool provider. An MCP host such as Copilot CLI, VS Code, Claude, etc. calls it to read or act on GitHub data. I don't see a GitHub MCP tool whose purpose is to create a new interactive Copilot Chat session on github.com.

For the synchronous conversational use case, however, the official GitHub Copilot SDK now looks like the appropriate API.

For example in TypeScript:

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient({
  workingDirectory: "/path/to/repository",
});

await client.start();

const session = await client.createSession({
  model: "auto",
});

const first = await session.sendAndWait({
  prompt: "Explain how authentication works in this repository.",
});

console.log(first?.data.content);

const followup = await session.sendAndWait({
  prompt: "Which tests cover that flow?",
});

console.log(followup?.data.content);

The important parts for the original use case are:

• createSession() creates a real conversation session.
• Reusing that session preserves the conversational context.
• sendAndWait() gives you synchronous request/response behaviour.
• workingDirectory gives the session a local repository as codebase context.
• The SDK supports persistent/resumable sessions.
• Nothing about this workflow inherently requires creating an issue, branch, or PR.

For a genuinely read-only exploration mode, the SDK also exposes onPermissionRequest. You can approve reads while rejecting write and shell requests (or run against a read-only checkout as an additional boundary).

So I would think of the architecture as:

your application
    ↓
Copilot SDK / conversational session
    ↓
local repository context
    +
optional MCP servers/tools

rather than:

your application
    ↓
GitHub MCP server
    ↓
open Copilot Chat

The GitHub MCP server can still be useful inside an agent session when you need GitHub-side repository/issues/PR/discussion context, but it is not itself the conversational Copilot host.

I can't speak to GitHub's roadmap for exposing the github.com Copilot Chat UI/session directly as an MCP tool, but for the underlying requirement — programmatic, interactive, multi-turn codebase Q&A without automatically creating a PR — the Copilot SDK now appears to provide that capability directly.