MCP Host, Client, Server with LLM - Sample Python Code

import socket
import openai
# Initialize the LLM API (e.g., OpenAI)
openai.api_key = "your_openai_api_key"

# MCP Server
def mcp_server(host='127.0.0.1', port=65432):
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((host, port))
server_socket.listen()
print(f"Server started on {host}:{port}")

while True:
client_socket, client_address = server_socket.accept()
print(f"Connection from {client_address}")
data = client_socket.recv(1024).decode()

if data:
print(f"Received: {data}")
# Process input with LLM
response = query_llm(data)
client_socket.send(response.encode())
client_socket.close()

# MCP Client
def mcp_client(message, host='127.0.0.1', port=65432):
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((host, port))
client_socket.send(message.encode())
response = client_socket.recv(1024).decode()
print(f"Response from server: {response}")
client_socket.close()

# MCP Host (MCP logic tying client-server communication)
def query_llm(prompt):
# Use the LLM to generate a response
try:
print(f"Querying LLM: {prompt}")
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=100
)
return response.choices[0].text.strip()
except Exception as e:
return f"Error querying LLM: {e}"

# To run
if __name__ == "__main__":
# Example: Launch Server
import threading
server_thread = threading.Thread(target=mcp_server)
server_thread.start()

# Example: Run Client
import time
time.sleep(1) # Give server time to start
mcp_client("Hello, LLM! How are you?")


Explanation MCP Server:

This Python function acts as the server in the MCP setup.
It listens for incoming connections from clients, processes their data, and sends back responses.
The server uses the query_llm function to integrate with an LLM API.

MCP Client:

The client connects to the server and sends a message (e.g., a user query).
It waits for the server's response and prints it.
LLM Integration:

The server processes input from the client using an external LLM API like OpenAI's GPT via query_llm.
Replace "your_openai_api_key" with your actual API key to make it functional.

Host Logic:

The host in this context is represented by the query_llm function, which facilitates communication between the MCP system and the LLM.
It ensures the server uses the LLM effectively to process and generate meaningful responses.
Concurrency:
The server runs in a separate thread to allow concurrent client-server communication.

How It Works:
Start the MCP server by running mcp_server in one thread.
The client (mcp_client) sends a message to the server.
The server passes the message to the LLM using the query_llm function.
The LLM processes the input and generates a response, which is sent back to the client.