Watsonx MCP Server

This project is a Python chatbot server based on IBM Watsonx.ai and the MCP protocol. It provides medical consultation functions, supports building a Web interface through Flask, and realizes symptom diagnosis and personalized greetings.

Artificial intelligence chatbots Customer support #Medical Chat #MCP Service #Watsonx .Python

rating : 2 points

downloads : 6.7K

update time : 2025-04-29

Open Site

What is the MCP Chatbot Server Based on Watsonx.ai?

This is a chatbot server that provides services through the Model Context Protocol (MCP). It uses the advanced large language model of IBM Watsonx.ai to generate intelligent responses. Whether you are developing an internal help desk or a public chatbot API, this model is easy to scale and adapt.

How to Use This Server?

First, ensure that your environment is correctly configured. Then run the server script and use the client tool to interact. For example, you can use the MCP Inspector to test the chat tool.

Applicable Scenarios

Suitable for chat applications that require powerful language model support, such as customer service systems and medical consultation assistants.

Main Features

Multi - purpose Chat Tool

Supports invoking the chat tool through the MCP protocol to achieve human - machine dialogue interaction.

Personalized Greetings

Can dynamically generate personalized greetings to enhance the user experience.

Symptom Assessment Tool

Integrates a symptom assessment tool that can generate medical advice based on the symptoms entered by the user.

Advantages

Powerful language model support to generate high - quality responses.

Modular design, easy to scale and reuse.

Supports multiple clients, such as MCP Inspector and custom Python clients.

Limitations

Requires a certain technical foundation to set up the environment and run the server.

Some advanced features may require additional fees or resources.

Sensitive to network latency and may perform poorly in low - bandwidth environments.

How to Use

Install Dependencies

Ensure that Python 3.9+ is installed and create a virtual environment to install the required dependencies.

Configure Environment Variables

Create a.env file and add your Watsonx.ai credentials.

Start the Server

Run the server.py script to start the MCP server.

Test the Chat Tool

Use the MCP Inspector to connect to the server and test the chat tool.

Usage Examples

Basic Chat Example

Send a simple message to the chat tool and receive a reply.

Symptom Assessment Example

Enter symptoms and get medical advice.

Frequently Asked Questions

How to load the.env file?

Why does the connection fail?

Does it support custom prompts?

Related Resources

Official Documentation

Learn more about the features of Watsonx.ai.

GitHub Code Repository

View the project source code.

Tutorial Video

Watch the detailed installation and configuration tutorial.

🚀 Complete Guide to Building a Full-Stack Chatbot Server with Watsonx.ai

This project demonstrates how to build a full-stack chatbot using Watsonx.ai and manage it through MCP (Machine Learning Platform). The solution features a clear hierarchical architecture, enabling conversation state storage, multi-turn conversation support, and seamless integration with Watsonx.ai's powerful LLM (Large Language Model).

📦 Project Structure

project/
├── server.py           # Main server entry point to start the Flask application
├── chatbot.py         # MCP client responsible for calling the Watsonx.ai service
├── templates/         # HTML template folder containing templates for three pages
│   ├── index.html     # Home page to collect the user's name
│   ├── symptoms.html  # Symptom input page
│   └── diagnosis.html # Diagnosis result display page
└── assets/            # Folder to store screenshots and other resource files

🚀 Quick Start

Implementation of server.py

from flask import Flask, request, render_template, redirect, url_for
import os

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/symptoms', methods=['POST'])
def symptoms():
    name = request.form.get('name')
    return render_template('symptoms.html', greeting=f'Hello {name}!')

@app.route('/diagnosis', methods=['POST'])
def diagnosis():
    symptoms = request.form.get('symptoms')
    # Call the MCP service to get the diagnosis result
    result = call_watsonx(symptoms)
    return render_template('diagnosis.html', diagnosis=result)

if __name__ == '__main__':
    app.run(debug=True, port=5000)

Implementation of chatbot.py

import os
from mcp.clients import MCPClient

# Initialize the MCP client
mcp = MCPClient(
    endpoint=os.getenv('MCP_ENDPOINT'), 
    api_key=os.getenv('MCP_API_KEY'),
    verbose=True  # Enable debug mode output
)

def call_watsonx(symptoms):
    # Use the predefined WatsonX model for diagnosis
    response = mcp.chat(
        model='watsonx-33b-instruct', 
        messages=[{
            'role': 'user',
            'content': f'Based on the symptoms {symptoms}, provide a medical diagnosis and recommendations.'
        }]
    )
    return response.choices[0].message.content

Implementation of HTML Templates

Home Page (index.html)

<!DOCTYPE html>
<html>
<head>
    <title>Watsonx Chatbot</title>
</head>
<body>
    <h1>Welcome to Watsonx Chatbot</h1>
    <form method="post">
        <label>Your Name:</label><br>
        <input type="text" name="name"><br>
        <button type="submit">Start Chatting</button>
    </form>
</body>
</html>

Symptom Page (symptoms.html)

<!DOCTYPE html>
<html>
<head>
    <title>Report Symptoms</title>
</head>
<body>
    <h1>{{ greeting }}</h1>
    <h2>Please describe your symptoms:</h2>
    <form method="post">
        <textarea name="symptoms" rows="4"></textarea><br>
        <button type="submit">Submit</button>
    </form>
</body>
</html>

Diagnosis Page (diagnosis.html)

<!DOCTYPE html>
<html>
<head>
    <title>Diagnosis Result</title>
</head>
<body>
    <h1>Your Medical Diagnosis:</h1>
    <pre>{{ diagnosis }}</pre>
</body>
</html>

🛠️ Troubleshooting

Common Issues and Solutions

Problem	Solution
Unable to connect to the MCP service	Check if the environment variables are correctly configured and ensure the API key is valid
Diagnosis result is empty	Ensure that the symptom description is complete and clear
Page fails to load	Check if the server is running properly on port 5000

💡 Best Practices

Use a virtual environment to manage dependencies.
Configure the .env file to store sensitive information.
Enable error logging for debugging purposes.
Regularly update the model version for optimal performance.

🚀 Expansion Suggestions

Implement session state storage (using Redis).
Add user authentication functionality.
Integrate third-party medical knowledge bases.
Optimize the UI to add more interactive features.

🌟 Conclusion

This project demonstrates how to build a complete chatbot system, providing a web interface through Flask and seamlessly integrating with Watsonx.ai's LLM service. This hierarchical architecture is not only easy to maintain but also convenient for expansion and optimization.

Readers can experience the full functionality of the chatbot by running the server.py and chatbot.py scripts in combination with the HTML template files.