Understanding the Model Context Protocol (MCP) and Model Context

📅

loading..🐩🐩🐩🐩

Before We Begin 🔗

Large language models (LLMs), such as the ones used in ChatGPT, have become more capable. It can still be hard to tell what information a model is using. The conversation it draws on and the source of its data can feel like a black box to the user.

The

Model Context Protocol

, or MCP, is an open standard introduced by Anthropic for connecting AI applications to external tools and data. A related design problem is how an application organizes the context it sends to a model. This article explores that problem through examples. The examples use a custom context format and do not implement the MCP wire protocol.

Models and Context: Why Does Context Matter? 🔗

When an AI model generates text or answers a question, it can use the context it was given, including the user's intent and the environment the application sets up. Context can take many forms:

Earlier messages in a conversation.
The topic or the stated goal of a task.
Information retrieved from external documents or data sources.
Settings for the project the user is working on.

An application needs a consistent way to manage and connect these inputs. A structured context format helps the application assemble them for the model. MCP can help provide external data and tools through a standard connection.

👨‍💻

Earlier messages in ChatGPT are one example of context. An application can organize the context it sends to a model, including information retrieved through an MCP connection.

What Is MCP? 🔗

MCP standardizes how a host application connects to servers that expose tools, resources, or prompts. The host decides how to combine the resulting information with inputs such as user details, conversation history, documents, and system instructions.

For the application's own context, the examples in this article use these fields:

system
holds basic rules or a role for the model, such as “Respond as a friendly TypeScript expert.”
tools
lists available capabilities, such as a code interpreter or search.
files
lists external references, such as PDFs, source files, and notes.
threads
represents conversation history and context.
user
holds information about the user, such as their name, role, or goal.

Together these fields tell the model who it is talking to, what the context is, and what role it should play.

Why Organize Context This Way? 🔗

Applications sometimes put all this information into one system prompt or mix it into conversation logs. That can make it hard to reuse context, keep it coherent, or share it across teams.

Separating context into fields can help when building custom

GPTs

AI assistants

, or

automated workflows

. MCP is useful when such applications need standardized access to external capabilities.

A Client–Server View of the Example 🔗

Conversational applications often run in a client–server architecture. Here is how the application in this article divides the work. These are application roles. In an MCP integration, an MCP client connects to a server that exposes capabilities.

Application Server 🔗

Receives user input, settings, and file uploads from the frontend.
Assembles system, tools, user, files, and thread information for the model request.
Sends the request to the OpenAI API or another LLM provider.

Application Client 🔗

Provides a user interface for chat input, file uploads, and settings.
Handles requests to change the context.
Maintains the server connection and application state.

Practical Examples 🔗

Custom GPTs in ChatGPT 🔗

OpenAI's GPT Builder lets you configure instructions, tools, files, and knowledge through an interface. These are examples of structured context. The interface alone does not establish that GPT Builder uses MCP internally.

When building a GPT, you can configure:

Basic behavior instructions (system).
Uploaded knowledge (files).
Which tools it can use (tools).

An Assistant for a Business 🔗

A company can use the OpenAI API to build an assistant that works with internal documents and policies. Its application might organize context this way:

system: “Follow company policies and guidelines.”
files: Uploaded internal documents.
user: Employee roles and permissions.

That context helps the assistant respond more consistently and accurately for each user or situation.

Define Your Own Context 🔗

When you build a custom GPT, the platform manages the settings you configure. You can also define similar fields yourself in an application. Here are two examples.

Example 1: A Personal Coding Assistant 🔗

const mcp = {
  system: "당신은 친절한 TypeScript 전문가입니다. 코드를 자세히 설명해 주세요.",
  tools: ["code_interpreter"],
  files: ["ts-guide.pdf", "my-project/index.ts"],
  user: {
    name: "Lee",
    role: "학생",
    goal: "타입스크립트 학습을 돕는 코드 리뷰",
  },
  threads: [
    {
      role: "user",
      content: "제 제너릭 함수에서 타입이 왜 추론되지 않는지 모르겠어요"
    }
  ]
}

This configuration gives the model enough guidance to respond in a friendly, concrete way consistently.

Example 2: A Product Planning GPT 🔗

system: “Think like a user-focused product manager in Silicon Valley.”
tools: ["browser", "web-search"]
files: ["market-research.xlsx", "user-feedback.txt"]
user: { name: "Hana", role: "Product planner" }

This configuration can change how the model behaves and responds based on what the user wants to accomplish.

Example: Build a Code Review Assistant 🔗

The example below uses a Node.js and Express backend and a React frontend to implement an AI code review service with structured context.

Server (Express) 🔗

// server/mcpRouter.ts
import express from 'express'
import { OpenAI } from 'openai'
const router = express.Router()
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! })
router.post('/ask', async (req, res) => {
  const { question, fileContent } = req.body
    const context = {
    system: '당신은 친절하고 꼼꼼한 TypeScript 코드 리뷰어입니다.',
    tools: ['code_interpreter'],
    files: [
      {
        name: 'index.ts',
        content: fileContent
      }
    ],
    user: {
      name: 'Lee',
      role: '학생'
    },
    threads: [
      { role: 'user', content: question }
    ]
  }
    const completion = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: context.system },
      { role: 'user', content: `파일 내용:
${fileContent}` },
      ...context.threads
    ]
  })
    res.json({ answer: completion.choices[0].message.content })
})
export default router

Client (React) 🔗

// client/components/Ask.tsx
import { useState } from 'react'
import axios from 'axios'
export default function Ask() {
  const [question, setQuestion] = useState('')
  const [file, setFile] = useState<File | null>(null)
  const [answer, setAnswer] = useState('')
    const handleSubmit = async () => {
    const text = await file?.text()
    const res = await axios.post('/api/ask', {
      question,
      fileContent: text
    })
    setAnswer(res.data.answer)
  }
    return (
    <div className="space-y-4">
      <input type="file" onChange={e => setFile(e.target.files?.[0] || null)} />
      <input
        value={question}
        onChange={e => setQuestion(e.target.value)}
        placeholder="질문을 입력하세요"
        className="border px-2 py-1"
      />
      <button onClick={handleSubmit} className="bg-blue-500 text-white px-4 py-2">요청하기</button>
      <pre className="bg-gray-100 p-2 whitespace-pre-wrap">{answer}</pre>
    </div>
  )
}

Conclusion 🔗

Clear, reusable context makes it easier to understand how an AI application works and to put it to work on real tasks. MCP provides a standard connection to external tools and data. You can combine that connection with a context structure suited to your application, whether you're building alone or with a team.

Further Considerations 🔗

Could you describe your context format with JSON Schema and version it?
How might the example work with React and LangChain?
What would change if you switched role and user settings dynamically?

References 🔗

OpenAI MCP documentation: https://openai.github.io/openai-agents-python/mcp/↗
GPT Builder: https://chat.openai.com/gpts↗
LangChain context management examples: https://docs.langchain.com↗

Understanding the Model Context Protocol (MCP) and Model Context | PromleeBlog