Deep Learning MCP Chatbot Setup

This README provides step-by-step instructions to set up the chatbot example notebook from scratch.

Prerequisites

• Anaconda/Miniconda installed
• Jupyter Notebook installed

Setup Instructions

1. Create and Activate Conda Environment

conda create -n deep_learning_mcp python=3.12 -y
conda activate deep_learning_mcp

2. Install Required Packages

Install the required packages using pip in the conda environment:

/opt/anaconda3/envs/deep_learning_mcp/bin/pip install arxiv python-dotenv anthropic

Or alternatively, if the environment is activated:

pip install arxiv python-dotenv anthropic

3. Create Jupyter Kernel

Register the conda environment as a Jupyter kernel:

python -m ipykernel install --user --name deep_learning_mcp --display-name "deep_learning_mcp"

4. Update Kernel Configuration (Important)

The kernel needs to point to the correct Python interpreter in the conda environment. Update the kernel configuration file:

File location: ~/Library/Jupyter/kernels/deep_learning_mcp/kernel.json

Update the argv section to use the conda environment Python:

{
 "argv": [
  "/opt/anaconda3/envs/deep_learning_mcp/bin/python",
  "-Xfrozen_modules=off",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "deep_learning_mcp",
 "language": "python",
 "metadata": {
  "debugger": true
 }
}

5. Launch Jupyter Notebook

jupyter notebook

6. Select the Correct Kernel

1. Open the chatbot_example_nb1.ipynb notebook
2. Go to Kernel → Change kernel → deep_learning_mcp
3. If the kernel is already selected, restart it: Kernel → Restart Kernel

7. Verify Setup

Run the import cell in the notebook to verify everything works:

import arxiv
import json
import os
from typing import List
from dotenv import load_dotenv
import anthropic

If there are no import errors, the setup is complete!

Troubleshooting

ModuleNotFoundError: No module named 'arxiv'

This error occurs when:

1. Packages are installed in the wrong Python environment
2. Kernel is using the wrong Python interpreter

Solution:

1. Ensure packages are installed in the conda environment: /opt/anaconda3/envs/deep_learning_mcp/bin/pip install ...
2. Verify the kernel.json file points to the correct Python path
3. Restart the Jupyter kernel after making changes

Kernel Not Found

If the deep_learning_mcp kernel doesn't appear in Jupyter:

1. Verify the kernel was created: jupyter kernelspec list
2. If missing, recreate it: python -m ipykernel install --user --name deep_learning_mcp --display-name "deep_learning_mcp"
3. Restart Jupyter Notebook

Environment Issues

To check available conda environments:

conda env list

To activate the environment:

conda activate deep_learning_mcp

Requirements File

The required packages are listed in requirements.txt:

arxiv
python-dotenv
anthropic

Usage

Once setup is complete, you can run the chatbot example notebook. The notebook includes:

1. Tool Functions: search_papers() and extract_info()
2. Chatbot Code: Tool mapping and execution
3. Interactive Chat Loop: Interface to interact with the chatbot

Example query to try:

• "Search for 2 papers on LLM interpretability"

Running MCP Server with Inspector

The MCP server can be run and tested using the MCP Inspector, which provides an interactive interface to test your server tools.

Prerequisites for MCP Server

1. Install MCP Inspector:

   pip install mcp-inspector
   

2. Create MCP Server:

   • Use the create_mcp_server.ipynb notebook to create your MCP server
   • This notebook will guide you through creating a server with the paper search tools

Running the Server with Inspector

1. Navigate to the project directory:

   cd /Users/sampathpulukurthi/Desktop/aiprojects/deep_learning_mcp
   

2. Activate the conda environment:

   conda activate deep_learning_mcp
   

3. Run the MCP Inspector:

   mcp-inspector
   

4. Connect your server:

   • The inspector will prompt you to connect to your MCP server
   • Provide the path to your server script or configuration
   • The inspector will display available tools and allow you to test them interactively

Using the Inspector Interface

The Inspector provides:

• Tool List: Shows all available tools from your MCP server
• Interactive Testing: Test each tool with custom parameters
• Real-time Results: See tool outputs immediately
• Debugging: Identify and fix issues with your server implementation

Example Workflow

1. Start the inspector: mcp-inspector
2. Connect to your paper search MCP server
3. List available tools: search_papers, extract_info
4. Test search_papers with topic "machine learning"
5. Test extract_info with a returned paper ID
6. Verify results and debug if needed

Benefits of Using Inspector

• Visual Interface: Easy-to-use command-line interface
• Real-time Testing: Immediate feedback on tool performance
• Debugging: Clear error messages and tool execution logs
• Documentation: Automatic tool documentation generation

Notes

• The chatbot uses Claude Sonnet 4.6 model via the Anthropic API
• Papers are stored in the papers/ directory organized by topic
• The chatbot does not persist memory across queries
• Make sure to set up your Anthropic API key in a .env file if not already done
• MCP Inspector is a powerful tool for testing and debugging MCP servers before integration