Using MCP in OpenAI

Using MCP in LLM Calls - With OpenAI Models

Unlocking OpenAI Model Potential with MCP

OpenAI models, such as GPT-4 or GPT-3.5, are at the forefront of AI capabilities. However, like all LLMs, their built-in knowledge has a cutoff point, and they cannot directly access real-time data, private repositories, or execute actions in external systems. The Model Context Protocol (MCP) offers a robust framework to overcome these limitations by seamlessly connecting OpenAI models to external data sources and tools, thereby enhancing their accuracy, relevance, and ability to perform tasks.

MCP functions like a standardized gateway. Your application, when using an OpenAI model, can leverage MCP to fetch necessary context or delegate actions, allowing the LLM to operate with a much broader and more dynamic set of information and capabilities.

Bridging OpenAI Models to External Data via MCP

MCP enables you to expose ‘resources’ through an MCP server. These resources can represent diverse data types: files on a server, database records, content from internal APIs, or even live data feeds like stock prices. When an application using an OpenAI model needs to provide it with specific, up-to-date, or confidential information, it can turn to an MCP client.

The workflow is straightforward: Your application, preparing a request for an OpenAI model, identifies a need for external context. It uses an MCP client to retrieve this data from a designated MCP server (e.g., a user’s purchase history from an e-commerce backend). The MCP server provides the data in a structured form. Your application then integrates this data into the prompt sent to the OpenAI model, enabling it to generate more contextually aware and accurate outputs.

• Example Data Sources: Internal company wikis, customer relationship management (CRM) data, code repositories, real-time sensor data.

Empowering OpenAI Models with External Tools through MCP

Often, interacting with an LLM involves more than just information retrieval; it requires action. MCP supports the definition of ‘tools’ – specific capabilities that an OpenAI model can request to use. These tools might include actions like sending a message, creating a database entry, interacting with a version control system, or invoking a custom business logic API. When an OpenAI model (often through its function calling capabilities) indicates a need for an action, your application can use MCP to fulfill this.

For example, if a user asks an OpenAI-powered assistant to find the latest sales report and then share its key findings with the sales team via email, the model might first process the report (provided as an MCP resource). Then, it could specify the need for an ‘email_tool’ (potentially using OpenAI’s function calling format). Your application would then interpret this, use an MCP client to invoke the corresponding tool on an MCP server (passing the findings and recipient list), and the MCP server would handle the email dispatch. The outcome of this action can then be fed back to the OpenAI model to inform the user.

• Example Tools: API interaction modules (e.g., for JIRA, GitHub), code execution environments, database manipulation tools, communication gateways (email, SMS).

Illustrative Scenario: MCP in Action with an OpenAI Model

Consider an AI-powered research assistant built using an OpenAI model (e.g., GPT-4). This assistant helps users gather information and draft documents. Here’s how MCP would amplify its effectiveness:

1. User Request: User asks, “Find recent articles on advancements in quantum computing published in the last month, summarize them, and save the summary to my ‘Research Notes’ folder.”

2. Data Retrieval (MCP Resource - Simulated): The application might first use a conventional search tool (or an MCP tool acting as a wrapper for a search API) to find recent articles. Let’s say it identifies several relevant online articles. To access proprietary research papers perhaps stored on a company server, it uses an MCP client: mcp_client.get_resource(server_id='internal_research_db', resource_path='/papers?topic=quantum&since=last_month').

3. Contextual Prompt for OpenAI Model: The content of fetched articles/papers (or their summaries) is compiled and included in the prompt to the OpenAI model: “Here is the content from recent articles on quantum computing: […article content…]. Please synthesize this information into a comprehensive summary. Then, prepare to save this summary.”

4. OpenAI Model Processing & Tool Indication (Function Calling): The OpenAI model processes the articles and generates a summary. It then indicates the need to use a ‘save_document’ tool, potentially using its native function calling feature, outputting a JSON like: {"function_name": "save_document_tool", "arguments": {"file_path": "Research Notes/quantum_summary.txt", "content": "...generated summary..."}}.

5. Tool Execution (MCP Tool): Your application receives this structured request from the OpenAI model. It then uses the MCP client to call the ‘save_document’ tool on an MCP server that manages file system operations or integrates with a document management system. Example MCP call (conceptual): mcp_client.execute_tool(server_id='file_storage_service', tool_id='save_file_to_user_drive', params={'path': 'Research Notes/quantum_summary.txt', 'data': '...generated summary...'}).

6. Result & Final Response: The MCP server executes the tool (saves the file), and the result (e.g., {'status': 'success', 'file_id': 'doc_xyz789'}) is returned to your application. This result is then provided back to the OpenAI model, which crafts a final response for the user: “I have summarized the recent advancements in quantum computing and saved the summary as ‘quantum_summary.txt’ in your ‘Research Notes’ folder.”

# Conceptual Python-like example for application logic

# mcp_client and openai_client are assumed to be initialized

# --- Phase 1: Fetching data using MCP for OpenAI model ---
def get_research_data_for_openai(topic, period):
    try:
        # This could be a combination of web search and MCP resources
        # For simplicity, let's assume an MCP resource provides curated data
        research_data = mcp_client.get_resource(
            server_id='internal_research_db',
            resource_path=f'/papers?topic={topic}&since={period}'
        )
        return f"Relevant research data on {topic} from {period}: {research_data}"
    except MCPError as e:
        print(f"MCP Error fetching research data: {e}")
        return f"Sorry, I couldn't retrieve research data on {topic}."

user_prompt_details = "Find recent articles on advancements in quantum computing published in the last month, summarize them, and save the summary to my 'Research Notes' folder."

# Application extracts topic and period
topic = "quantum computing"
period = "last_month"

context_from_mcp = get_research_data_for_openai(topic, period)

# messages_for_openai = [
#     {"role": "system", "content": "You are a helpful research assistant. When asked to save a file, use the 'save_document_tool'."},
#     {"role": "user", "content": f"{context_from_mcp}\n\nUser instruction: {user_prompt_details}"}
# ]

# tools_definition_for_openai = [
#     {
#         "type": "function",
#         "function": {
#             "name": "save_document_tool",
#             "description": "Saves a document to a specified path with given content.",
#             "parameters": {
#                 "type": "object",
#                 "properties": {
#                     "file_path": {"type": "string", "description": "The path where the file should be saved, e.g., 'Research Notes/summary.txt'"},
#                     "content": {"type": "string", "description": "The content of the document to save."}
#                 },
#                 "required": ["file_path", "content"]
#             }
#         }
#     }
# ]

# openai_response = openai_client.chat.completions.create(
#     model="gpt-4",
#     messages=messages_for_openai,
#     tools=tools_definition_for_openai,
#     tool_choice="auto"
# )
# response_message = openai_response.choices[0].message
# tool_calls = response_message.tool_calls

# --- Phase 2: OpenAI model indicates tool use, executed via MCP ---
# if tool_calls:
#     for tool_call in tool_calls:
#         if tool_call.function.name == 'save_document_tool':
#             function_args = json.loads(tool_call.function.arguments)
#             try:
#                 mcp_tool_result = mcp_client.execute_tool(
#                     server_id='file_storage_service',
#                     tool_id='save_file_to_user_drive', # MCP server's tool ID
#                     params=function_args
#                 )
#                 print(f"MCP Tool execution result: {mcp_tool_result}")

#                 # Send result back to OpenAI model for final user response generation
#                 # messages_for_openai.append(response_message) # Add assistant's turn
#                 # messages_for_openai.append(
#                 #     {
#                 #         "tool_call_id": tool_call.id,
#                 #         "role": "tool",
#                 #         "name": 'save_document_tool',
#                 #         "content": json.dumps(mcp_tool_result)
#                 #     }
#                 # )
#                 # final_user_response = openai_client.chat.completions.create(
#                 #     model="gpt-4",
#                 #     messages=messages_for_openai
#                 # ).choices[0].message.content
#                 # print(final_user_response)

#             except MCPError as e:
#                 print(f"MCP Tool Error: {e}")
                # Handle error, potentially inform OpenAI model or user

This example illustrates how MCP, by standardizing access to external data and tools, can significantly augment the capabilities of OpenAI models, enabling them to participate in more complex and useful workflows, especially when leveraging their function calling features.