FROM feat/4-transition-to-mcp-interface TO development

.gitignore

@@ -2,4 +2,5 @@ uploads
 downloads
 toolkilt/.venv/
 toolkilt/__pycache__/
-toolkilt/tools/__pycache__/
+toolkilt/tools/__pycache__/
+**/__pycache__/

.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: MCP Server",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/api.py",
+            "console": "integratedTerminal",
+            "justMyCode": false,
+            "env": {
+                "PYTHONPATH": "${workspaceFolder}",
+                // "FASTMCP_DEBUG": "true",
+                // "FASTMCP_LOG_LEVEL": "DEBUG",
+                "PYDEVD_DISABLE_FILE_VALIDATION": "1"
+            }
+        }
+    ]
+}

Dockerfile

@@ -1,11 +1,15 @@
 # Use the official Jupyter Notebook image
 FROM jupyter/base-notebook:latest
 
-# Install FastAPI and Uvicorn
-RUN pip install fastapi uvicorn python-multipart
-
 # Copy the API script to the root directory
+COPY src /home/jovyan/src
 COPY api.py /home/jovyan/api.py
+COPY requirements.txt /home/jovyan/requirements.txt
+
+# Install FastAPI and Uvicorn
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir uv && \
+    uv pip install --system --no-cache-dir -r requirements.txt
 
 # Expose port 8888 for the Jupyter Notebook
 EXPOSE 8888

api.py

@@ -1,30 +1,23 @@
 from fastapi import FastAPI, HTTPException, File, UploadFile, Form
-from pydantic import BaseModel
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, JSONResponse
 import subprocess
 import os
-import shutil
-from typing import List, Dict
+import uuid
 
-app = FastAPI()
-
-class CodeExecutionRequest(BaseModel):
-    session_id: str
-    code: str
-    env: Dict[str, str] = {}
+from src.entities import *
+from src.controllers import ExecController
 
-class PackageInstallationRequest(BaseModel):
-    session_id: str
-    packages: List[str]
+app = FastAPI()
+exec_controller = ExecController()
+session_manager = {}
 
-class TerminateSessionRequest(BaseModel):
-    session_id: str
 
-session_manager = {}
+def get_session_id(request: SessionId):
+    return request.session_id or str(uuid.uuid4())
 
 @app.post("/install")
-def install_packages(request: PackageInstallationRequest):
-    session_id = request.session_id
+def install_packages(request: PackageInstall):
+    session_id = get_session_id(request)
 
     if session_id not in session_manager:
         session_manager[session_id] = {
@@ -34,18 +27,19 @@ def install_packages(request: PackageInstallationRequest):
 
     try:
         # Install packages if any are provided and not already installed
-        for package in request.packages:
-            if package not in session_manager[session_id]["packages"]:
-                subprocess.check_call([f"pip install {package}"], shell=True)
-                session_manager[session_id]["packages"].add(package)
-
-        return {"status": "success", "installed_packages": list(session_manager[session_id]["packages"])}
+        return JSONResponse(
+            status_code=200, 
+            content={
+                'id': session_id,
+                **exec_controller.install_packages(session_id, session_manager, request.packages)
+            }
+        )
     except subprocess.CalledProcessError as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/execute")
-def run_code(request: CodeExecutionRequest):
-    session_id = request.session_id
+def run_code(request: CodeExecution):
+    session_id = get_session_id(request)
 
     if session_id not in session_manager:
         session_manager[session_id] = {
@@ -58,23 +52,42 @@ def run_code(request: CodeExecutionRequest):
         for key, value in request.env.items():
             os.environ[key] = value
 
-        # Create session directory if it doesn't exist
-        session_dir = f"/tmp/{session_id}"
-        os.makedirs(session_dir, exist_ok=True)
-
         # Write code to a temporary file
-        code_file_path = f"{session_dir}/temp_code.py"
-        with open(code_file_path, "w") as code_file:
-            code_file.write(request.code)
+        code_file_path = exec_controller.exec_service.write_code(session_id, request.code)
         session_manager[session_id]["files"].add(code_file_path)
 
-        # Run the code
-        result = subprocess.run(["python", code_file_path], capture_output=True, text=True)
-
-        return {"status": "success", "output": result.stdout, "errors": result.stderr}
+        return JSONResponse(
+            status_code=200, 
+            content={
+                'id': session_id,
+                **exec_controller.execute_python(code_file_path).model_dump()
+            }
+        )
+
     except subprocess.CalledProcessError as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.post("/terminate")
+def terminate_session(request: SessionId):
+    session_id = get_session_id(request)
+
+    if session_id not in session_manager:
+        raise HTTPException(status_code=404, detail="Session not found.")
+
+    try:
+        deleted_session = exec_controller.exec_service.uninstall_packages(session_id, session_manager)
+        return JSONResponse(
+            status_code=200, 
+            content={
+                'id': session_id,
+                **deleted_session
+            }
+        )
+    except subprocess.CalledProcessError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.post("/upload")
 async def create_upload_file(session_id: str = Form(...), file: UploadFile = File(...)):
     if session_id not in session_manager:
@@ -84,48 +97,14 @@ async def create_upload_file(session_id: str = Form(...), file: UploadFile = Fil
         }
 
     try:
-        # Create session directory if it doesn't exist
-        session_dir = f"/tmp/{session_id}"
-        os.makedirs(session_dir, exist_ok=True)
-
-        file_location = f"{session_dir}/{file.filename}"
-        with open(file_location, "wb+") as file_object:
-            shutil.copyfileobj(file.file, file_object)
-
-        session_manager[session_id]["files"].add(file_location)
-
-        return {"filename": file.filename, "location": file_location}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/terminate")
-def terminate_session(request: TerminateSessionRequest):
-    session_id = request.session_id
-
-    if session_id not in session_manager:
-        raise HTTPException(status_code=404, detail="Session not found.")
-
-    try:
-        # Uninstall packages
-        packages_to_remove = " ".join(session_manager[session_id]["packages"])
-        if packages_to_remove:
-            subprocess.check_call([f"pip uninstall -y {packages_to_remove}"], shell=True)
-
-        # Remove files and directory
-        for file_path in session_manager[session_id]["files"]:
-            if os.path.exists(file_path):
-                os.remove(file_path)
-
-        session_dir = f"/tmp/{session_id}"
-        if os.path.exists(session_dir):
-            os.rmdir(session_dir)
-
-        # Clean up session
-        del session_manager[session_id]
-
-        return {"status": "success", "message": f"Session {session_id} terminated successfully."}
-    except subprocess.CalledProcessError as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        upload_file = exec_controller.upload_file(session_id, session_manager, file)
+        return JSONResponse(
+            status_code=200, 
+            content={
+                'id': session_id,
+                **upload_file
+            }
+        )
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -141,4 +120,4 @@ def download_file(session_id: str, filename: str):
 
 if __name__ == '__main__':
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8020)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+python-multipart
+python-dotenv

src/config/__init__.py

@@ -0,0 +1,8 @@
+import os
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    API_URL = os.getenv("API_URL", "http://localhost:8020")

src/controllers/__init__.py

@@ -0,0 +1,29 @@
+from fastapi import File, UploadFile
+from src.services.exec import ExecService
+from typing import List, Dict, Any
+import uuid
+
+class ExecController:
+    def __init__(self):
+        self.exec_service: ExecService = ExecService()
+        self.session_manager: Dict[str, Any] = {}
+
+    def create_session(self):
+        session_id = str(uuid.uuid4())
+        self.session_manager[session_id] = {
+            "packages": set(),
+            "files": set()
+        }
+        return session_id
+
+    def execute_python(self, code_file_path: str):
+        return self.exec_service.execute_python(code_file_path)
+
+    def install_packages(self, session_id: str, session_manager, packages: List[str]):
+        return self.exec_service.install_packages(session_id, session_manager, packages)
+
+    def upload_file(self, session_id: str, session_manager, file: UploadFile = File(...)):
+        return self.exec_service.upload_file(session_id, session_manager, file)
+
+    def uninstall_packages(self, session_id: str, session_manager):
+        return self.exec_service.uninstall_packages(session_id, session_manager)

src/entities/__init__.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import Dict, List
+
+class SessionId(BaseModel):
+    session_id: str = None
+
+class CodeExecution(SessionId):
+    code: str
+    env: Dict[str, str] = {}
+
+class PackageInstall(SessionId):
+    packages: List[str]
+
+class PythonResult(BaseModel):
+    status: str
+    output: str
+    errors: str