Turn Your AI Agent into an MCP Server for ChatGPT, Claude and Cursor

Turn Your AI Agent into an MCP Server for ChatGPT, Claude & Cursor

Piotr Grudzień

on July 5, 2026 • 23 min read

; the original PNG/JPG stays as the fallback and remains the og:image for social scrapers. -->

Introduction

Every tutorial in this series so far has connected a Quickchat AI Agent to something: Telegram, Google Sheets, Discord. This one inverts the direction. Your agent becomes the thing other AIs connect to: a tool that ChatGPT, Claude and Cursor call when their users ask something only your agent knows.

The mechanism is an MCP server, and the setup is deliberately boring: every Quickchat AI Agent already has one, hosted at a URL of the form https://app.quickchat.ai/mcp/your-agent-id. You switch it on, copy the URL, and paste it into the AI app as a connector. That is the whole integration, and it takes no code. Access is private by default: connecting requires signing in with your Quickchat AI account until you decide otherwise.

By the end of this guide you will have built a support agent for a fictional developer-tools company, given it real knowledge, exposed it as an MCP server, connected it to real AI apps, and watched something genuinely new in your Inbox: two AIs talking to each other about your product, with your agent capturing a sales lead from inside a chat app along the way. We also cover what the calling AI refuses to do, which turned out to be the most interesting finding in this post.

You need two things:

a Quickchat AI Agent (sign up here and use for free; MCP is included in the Free plan)

at least one MCP client: Claude (free plan works), ChatGPT (paid plan, developer mode), Cursor, or any app from the MCP client directory

The canonical reference for this feature lives in the docs at docs.quickchat.ai/channels/mcp. If MCP itself is new to you, our MCP explainer covers the protocol in detail; this post only needs the one-paragraph version below.

What you will build

A fictional company, Orbit, sells a hosted vector-search API to developers. Their support agent knows the docs: plans, rate limits, regions, authentication, SDKs. You will expose that agent as an MCP server and drive five behaviors from real AI apps:

#You ask the AI appWhat your agent doesWhere you see it

1”What are Orbit’s rate limits on the free plan?”Answers from the Knowledge BaseThe app’s chat + your Inbox

2”Does Orbit have a Ruby SDK?”Says it does not know (the fact is missing on purpose)The app relays the honest no

3”Get me a demo, here are my details”Captures the lead with Smart Data GatheringContact details in the Inbox

4”Put me through to a human”Triggers Human HandoffConversation reassigned to your team

5A follow-up questionContinues the same conversationOne thread in the Inbox

Everything below was built and tested for real against the running product, and every screenshot is a genuine capture. Where a screen belongs to an external app, we say exactly where to click.

Who calls who: MCP client, MCP server, AI Agent, AI Action

These four terms get mixed up constantly, including by people who ship MCP servers for a living. One sentence each:

An MCP client is the AI app your user talks to (ChatGPT, Claude, Cursor). It decides when to call a tool.

An MCP server is the thing that offers tools. Here, Quickchat AI hosts one per agent at https://app.quickchat.ai/mcp/.

The AI Agent is your agent: the Knowledge Base, the prompt, the behavior you configured. The MCP server is just its socket.

AI Actions are what your agent itself can do during a reply (call APIs, capture leads, hand off to a human). They keep working when the question arrives via MCP.

The full chain. Note who decides to call the tool: the MCP client, not you and not your agent.

MCP (Model Context Protocol) is the standard that makes the middle arrows work: a uniform way for an AI app to discover a server’s tools and call them. The transport is plain HTTPS (streamable HTTP, if you care about the wire details), which is why one URL is the entire integration surface.

The important inversion to internalize: the calling model reads your tool’s name and description and decides by itself when your agent is worth calling. You do not get to force it. Everything in the tuning section follows from this.

Three things worth knowing before you build

Before the walkthrough, three facts about how the server behaves:

One tool per agent. The server exposes a single tool (you will name it; ours is ask_orbit) that takes one string argument, message, and returns your agent’s reply. The tool is annotated read-only: it cannot modify anything, on your account or anywhere else.

Sessions map to conversations. Each MCP session maps to one conversation in your Inbox. A client that keeps its session alive across calls threads follow-ups into that same conversation; many chat apps open a fresh session per question, though, so in practice you will often see each question land as its own conversation. Idle sessions expire after a few hours.

It is your real agent. The call goes through the same reply pipeline as your website widget. Knowledge Base retrieval, AI Actions, Smart Data Gathering and Human Handoff all behave exactly as they do on your site, and every reply consumes the same AI message credits.

Step 1: Create the Orbit agent and give it knowledge

Create your agent (the Getting Started flow takes a few minutes) and set its identity. Orbit’s main prompt is one paragraph:

You are Orbit's developer support assistant. Orbit is a hosted vector search API for developers. Answer questions about Orbit's plans, rate limits, regions, authentication, SDKs and search features using your Knowledge Base. Be concise and technical. If something is not covered by your knowledge, say plainly that you do not know.

Then open Knowledge Base and add articles. Orbit has six short ones: plans and pricing, rate limits, regions and data residency, authentication and API keys, SDKs and API clients, hybrid search. Real facts your agent should state exactly, for example:

Rate limits by plan: Free allows 60 queries per minute and 120 writes per minute. Pro allows 600 queries per minute and 1,200 writes per minute. Scale limits are custom. Limits are enforced per project with a token bucket. When you exceed a limit the API returns HTTP 429 with a Retry-After header. A batch upsert counts as one write per 100 vectors.

Orbit’s Knowledge Base. Six articles cover the product; the SDK article deliberately lists Python, TypeScript and Go but not Ruby.

Note the deliberate gap: the SDK article does not mention Ruby. That is on purpose. A support agent’s most important behavior is what it does when it does not know, and we want to test that honestly rather than only lob softballs.

If you want the deeper Knowledge Base guide, the docs page on building an effective Knowledge Base covers sources, tags and retraining.

Step 2: Turn on your MCP server

Open External Apps in the sidebar and click the MCP tile.

MCP sits next to the other external surfaces: API and the per-platform integrations.

The MCP panel has everything on one screen: an Enable MCP toggle, a Configure MCP dialog, a Connect MCP dialog, and the Require sign-in (private) toggle.

The whole MCP surface. Enable it, describe your agent, copy the URL.

Flip Enable MCP on, then open Configure MCP. This dialog is more important than it looks; we will spend a whole section on why. It has three fields:

The three strings the calling AI reads. They are the interface between your agent and every AI app that connects.

Name: how AI apps see your agent. Ours: Orbit Docs Assistant.

Description: 2 to 3 sentences on what your agent knows and can do, and what it cannot. The calling model uses this to decide when to call your agent at all, so write it like an API contract, not marketing copy. Ours:

Answers developer questions about Orbit, the hosted vector search API: plans and pricing, rate limits, regions, authentication and SDKs. It answers only from Orbit's own documentation and says so when something is not covered. It can also register a follow-up request (a demo, Scale plan pricing, a rate limit increase): pass along the user's contact details and the Orbit team will reach out.

Command: the tool name the AI app sees, letters and underscores. Ours: ask_orbit. Pick something a model would naturally reach for.

Then open Connect MCP and copy your MCP server URL:

https://app.quickchat.ai/mcp/

The whole integration surface: one URL, a Copy button, and the per-app step. Copy it, paste it, done.

The same dialog lists the per-app steps we follow next. Leave Require sign-in (private) on for now; it is the default, and it means nobody can use your agent through MCP without signing in to your Quickchat AI workspace. We flip it to public later, deliberately, once you understand the tradeoff.

Step 3: Connect from Claude

In Claude, open Settings, find Connectors (currently under the Customize section), click Add, then Add custom connector. Give it a name and paste your MCP server URL. Claude supports custom connectors on every plan, including the free one (free accounts can add one custom connector).

The whole setup in Claude: a name and the URL. The OAuth fields stay empty; Quickchat AI handles auth for you.

Because your server is private, Claude will send you through a sign-in step the first time: a normal Quickchat AI login page opens, you sign in, and the connector completes. No consent screens, no tokens to copy. Anyone who is not a member of your workspace stops here.

Private mode in practice: the AI app bounces you to the regular Quickchat AI sign-in. Your team gets in, nobody else does.

Now ask Claude something only Orbit knows:

What are Orbit's rate limits on the free plan?

Claude recognizes the question is in ask_orbit’s territory, calls the tool, and relays your agent’s answer: 60 queries per minute, 120 writes per minute, and the three regions. Those numbers come from your Knowledge Base article, not from the model’s imagination.

“Loaded tools, used Orbit integration”: Claude called your agent and relayed exactly what its Knowledge Base says. The reader is talking to Claude; the facts are yours.

Then ask the trap question:

Does Orbit have a Ruby SDK?

Your agent says the docs do not mention one, and Claude relays the honest no. In our run it checked the Knowledge Base, reported that there is no official Ruby SDK, correctly listed the SDKs that do exist (Python, TypeScript, Go), and suggested calling the plain REST API from Ruby instead:

The honest no, with a useful alternative. Claude did not invent a Ruby SDK; it relayed what your Knowledge Base actually says and pointed to the REST route instead.

The same exchange is waiting in your Inbox as a normal MCP conversation, so you see the question your agent was asked and the answer it gave:

Your side of the same conversation. The agent answered from the Knowledge Base and said plainly what it does not cover, with no hallucinated SDK.

This is the payoff of the deliberate gap from Step 1: you have now seen the whole honesty chain work end to end, agent to model to user.

Step 4: Connect from ChatGPT

ChatGPT gates custom MCP connectors behind developer mode, which requires a paid plan. Go to Settings, then Apps, open Advanced settings, and turn on Developer mode. ChatGPT labels it “elevated risk,” because in developer mode a connector can do whatever its tools allow, so ChatGPT wants you to opt in deliberately.

Developer mode is the one switch that unlocks custom connectors in ChatGPT. It is honest about the tradeoff; ours is a read-only tool, but the warning applies to any server you add.

Now click Create app: set the connection to Server URL, paste your MCP server URL, and (for a public agent) choose No Auth.

Name it, paste the URL, tick the acknowledgement, Create. The risk copy is ChatGPT’s, and it is fair: only add servers you trust, and yours is one you control.

ChatGPT shows a fi

[truncated for AI cost control]