Update app.py

app.py

@@ -1,437 +1,9 @@
-from fastmcp import FastMCP
-import requests
+from fastapi import FastAPI
+from fastapi_mcp import FastApiMCP
 
-# Step 1: Create the server
-mcp = FastMCP(name="MCP Server with Standardized Tools")
-
-
-# Step 2: Add tools with proper naming and documentation
-@mcp.tool
-def calculate_sum(first_number: int, second_number: int) -> int:
-    """
-    This tool adds two integer numbers and returns their sum.
-    
-    When to use:
-    - When simple mathematical addition is required
-    - As a basic calculator function
-    
-    Limitations:
-    - Only handles integers, not floating point numbers
-    - No validation for integer overflow
-    
-    Parameters:
-    - first_number: The first integer to be added
-    - second_number: The second integer to be added
-    
-    Returns:
-    - The sum of the two provided integers
-    """
-    return first_number + second_number
-
-
-@mcp.tool
-def count_file_rows(file_path: str) -> int:
-    """
-    This tool counts the number of rows (lines) in a text file.
-    
-    When to use:
-    - When you need to know the total number of lines in a file
-    - For analyzing file size in terms of line count
-    - Before processing files to understand their scope
-    
-    Limitations:
-    - Only works with text files that can be read line by line
-    - Very large files may take time to process
-    - Binary files may produce unexpected results
-    
-    Parameters:
-    - file_path: The absolute or relative path to the file to count rows for
-    
-    Returns:
-    - The total number of rows (lines) in the file as an integer
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as file:
-            row_count = sum(1 for line in file)
-        return row_count
-    except FileNotFoundError:
-        raise ValueError(f"File not found: {file_path}")
-    except PermissionError:
-        raise ValueError(f"Permission denied accessing file: {file_path}")
-    except UnicodeDecodeError:
-        # Try with different encoding for non-UTF-8 files
-        try:
-            with open(file_path, 'r', encoding='latin-1') as file:
-                row_count = sum(1 for line in file)
-            return row_count
-        except Exception:
-            raise ValueError(f"Unable to read file (encoding issue): {file_path}")
-    except Exception as e:
-        raise ValueError(f"Error reading file: {e}")
-
-
-# Step 3: Add a static resource (resources follow their own convention)
-@mcp.resource("resource://config")
-def get_config() -> dict:
-    """
-    Provides the application's configuration.
-    
-    When to use:
-    - When configuration values are needed across the application
-    
-    Returns:
-    - A dictionary containing version and author information
-    """
-    return {"version": "1.0", "author": "MyTeam"}
-
-
-# Step 4: Add a resource template for dynamic content
-@mcp.resource("greetings://{name}")
-def personalized_greeting(name: str) -> str:
-    """
-    Generates a personalized greeting for the given name.
-    
-    Parameters:
-    - name: The person's name to include in the greeting
-    
-    Returns:
-    - A personalized greeting string
-    """
-    return f"Hello, {name}! Welcome to the MCP server."
-
-
-@mcp.tool
-def query_tax_advice(question: str) -> str:
-    """
-    This tool sends tax-related questions to the ATO API and returns the response.
-    
-    When to use:
-    - When users need tax information or guidance
-    - For tax compliance queries
-    
-    Limitations:
-    - Limited to Australian tax regulations
-    - Responses are informational only and not legal advice
-    - API rate limits apply (max 100 requests per hour)
-    
-    Parameters:
-    - question: The tax-related question in natural language format
-    
-    Returns:
-    - A string containing the ATO's response to the tax query
-    """
-    url = "https://kaballas-doe-work.hf.space/api/v1/openai/chat/completions"
-    headers = {
-        "accept": "*/*",
-        "Authorization": "Bearer PF9RE8T-7DFMFQ9-P14FTVJ-640YR2Y",
-        "Content-Type": "application/json",
-    }
-    data = {
-        "messages": [
-            {"role": "system", "content": "You are a helpful assistant"},
-            {"role": "user", "content": question},
-        ],
-        "model": "tax",
-        "stream": False,
-        "temperature": 0.7,
-    }
-    print("\n--- DEBUG ---")
-    print("User question:", question)
-    print("Request headers:", headers)
-    print("Request payload:", data)
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        print("Response status code:", response.status_code)
-        print("Raw response:", response.text)
-        response.raise_for_status()
-        print("Response JSON:", response.json())
-        return str(response.json())
-    except Exception as e:
-        print("Exception occurred:", e)
-        return f"Error: {e}"
-
-
-@mcp.tool
-def generate_qa_plan(task: str, deadline: str) -> str:
-    """
-    This tool generates a structured QA plan based on the given task and deadline.
-    
-    When to use:
-    - When creating test plans for software projects
-    - For establishing QA workflows with specific deadlines
-    
-    Limitations:
-    - Plans are templates and may need customization
-    - Does not integrate with project management tools
-    
-    Parameters:
-    - task: A description of the task requiring QA planning
-    - deadline: The date by which the QA process must be completed (format: YYYY-MM-DD)
-    
-    Returns:
-    - A formatted string containing the QA plan with todo items
-    """
-    todo = f""" {task}
-    
-    IMPORTANT: Recursively fetching links is crucial. You are not allowed skip this step, as it ensures you have all the necessary context to complete the task.
-
-### Read File Tool (`functions.read_file`)
-
-1. Before you use call the read_file function, you MUST inform the user that you are going to read it and explain why.
-
-2. Always read the entire file. You may read up to 2000 lines in a single read operation. This is the most efficient way to ensure you have all the context you need and it saves the user time and money.
-
-3. Unless a file has changed since the last time you read it.
-
-IMPORTANT: Read the entire file. Failure to do so will result in a bad rating for you.
-- [ ] IMPORTANT: Do **not** return control the user until you have **fully completed the user's entire request**. All items in your todo list MUST be checked off. Failure to do so will result in a bad rating for you.
-- [ ] Validate if action is complete
-
-"""
-    return todo
-
-
-@mcp.tool
-def generate_python_code(task: str) -> str:
-    """
-    This tool generates Python code that accomplishes the described task.
-    
-    When to use:
-    - When users need Python implementation examples
-    - For automating Python code generation based on requirements
-    
-    Limitations:
-    - Generated code may require review and optimization
-    - Complex algorithms might not be optimally implemented
-    - Does not handle external dependencies or package installations
-    
-    Parameters:
-    - task: A description of what the Python code should accomplish
-    
-    Returns:
-    - A string containing the generated Python code with explanatory comments
-    """
-    url = "https://kaballas-doe-work.hf.space/api/v1/openai/chat/completions"
-    headers = {
-        "accept": "*/*",
-        "Authorization": "Bearer PF9RE8T-7DFMFQ9-P14FTVJ-640YR2Y",
-        "Content-Type": "application/json",
-    }
-    prompt = f"""Task is to write python code for the following task : '{task}' . """
-
-    data = {
-        "messages": [
-            {"role": "system", "content": "You are a helpful assistant"},
-            {"role": "user", "content": prompt},
-        ],
-        "model": "python",
-        "stream": False,
-        "temperature": 0.7,
-    }
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        # Extract and return only the 'content' field from the 'assistant' message
-        return response.json()["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"Error: {e}"
-
-
-@mcp.tool
-def query_sap_knowledge(question: str) -> str:
-    """
-    This tool provides answers to SAP-related questions by querying a specialized knowledge model.
-    
-    When to use:
-    - When users need information about SAP systems, modules, or best practices
-    - For troubleshooting SAP-specific issues
-    
-    Limitations:
-    - Knowledge base may not cover the latest SAP updates
-    - Technical implementation details may vary by SAP version
-    - Some specialized modules may have limited coverage
-    
-    Parameters:
-    - question: The SAP-related question in natural language format
-    
-    Returns:
-    - A detailed response addressing the SAP question
-    """
-    url = "https://kaballas-doe-work.hf.space/api/v1/openai/chat/completions"
-    headers = {
-        "accept": "*/*",
-        "Authorization": "Bearer PF9RE8T-7DFMFQ9-P14FTVJ-640YR2Y",
-        "Content-Type": "application/json",
-    }
-    prompt = f"""Anwser the SAP related Question  '{question}' . """
-
-    data = {
-        "messages": [
-            {"role": "system", "content": "You are a helpful assistant"},
-            {"role": "user", "content": prompt},
-        ],
-        "model": "sap",
-        "stream": False,
-        "temperature": 0.7,
-    }
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        # Extract and return only the 'content' field from the 'assistant' message
-        return response.json()["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"Error: {e}"
-
-
-@mcp.tool(
-    title="Task Analysis & Planning"
-)
-def interpret_task(task: str, deadline: str = "") -> str:
-    """
-    This tool analyzes a given task and generates a structured plan for completion.
-    
-    When to use:
-    - As the first step in processing any user request
-    - For breaking down complex tasks into manageable steps
-    
-    Limitations:
-    - Generated plans may need adjustment for specialized domains
-    - Cannot account for all edge cases in complex workflows
-    - Task interpretation quality depends on input clarity
-    
-    Parameters:
-    - task: The description of the task to be analyzed and planned
-    - deadline: Optional deadline for task completion (format: YYYY-MM-DD)
-    
-    Returns:
-    - A structured plan with steps to complete the task
-    """
-    url = "https://kaballas-doe-work.hf.space/api/v1/openai/chat/completions"
-
-    headers = {
-        "accept": "*/*",
-        "Authorization": "Bearer PF9RE8T-7DFMFQ9-P14FTVJ-640YR2Y",
-        "Content-Type": "application/json",
-    }
-
-    # Step 1: Send request to TaskInterpreter model
-    prompt = f"""INSTRUCTIONS: MCP TOOLING AND SCHEMA COMPLIANCE
-
-----------------------------------------
-AVAILABLE TOOLS (DO NOT USE ANY OTHERS)
-----------------------------------------
-
-{{
-  "tools": [
-    {{
-      "name": "calculate_sum",
-      "description": "Adds two integers and returns the result. Intended for basic integer addition tasks."
-    }},
-    {{
-      "name": "count_file_rows",
-      "description": "Counts the number of lines in a text file. Useful for gauging file size or preprocessing needs."
-    }},
-    {{
-      "name": "query_tax_advice",
-      "description": "Sends a natural language tax-related question to an ATO model and returns a response. Limited to Australian tax domain."
-    }},
-    {{
-      "name": "generate_qa_plan",
-      "description": "Generates a checklist-style QA plan for a task and deadline, including mandatory procedural steps."
-    }},
-    {{
-      "name": "generate_python_code",
-      "description": "Returns Python code that fulfills a user-described programming task. Output is raw code with inline comments."
-    }},
-    {{
-      "name": "query_sap_knowledge",
-      "description": "Answers SAP-related questions using a specialized model trained on SAP system knowledge."
-    }},
-    {{
-      "name": "interpret_task",
-      "description": "Analyzes a task and produces a structured execution plan. Often used as a first step before tool invocation."
-    }}
-  ],
-  
-}}
-
-----------------------------------------------------
-MCP TOOLING RULES (ALL MUST BE FOLLOWED STRICTLY)
-----------------------------------------------------
-
-1. STRUCTURED RESULTS & SCHEMA COMPLIANCE
-
-- All tool results must be structured JSON.
-- If a tool defines an `outputSchema`, your output MUST conform exactly.
-- Match all field names, data types, and required properties — no omissions, additions, or type mismatches.
-- Clients and systems will validate JSON against this schema.
-
-2. TOOL NAMING CONVENTION
-
-- Use only lowercase snake_case format: verb_noun
-- The name must describe what the tool does and to what.
-- DO NOT use vague names like `add`, `doTask`, or `Handler`.
-
-Examples:
-✓ calculate_sum
-✓ query_tax_advice
-✓ interpret_task
-✗ Add
-✗ ATO_HELP
-✗ TaskInterpreter
-
-3. JSON OUTPUT REQUIREMENT
-
-- Every tool result MUST return JSON only.
-- DO NOT include markdown, comments, or explanatory text outside of the JSON object.
-- Validate your output before returning it.
-
-4. EXISTING USER GUIDELINES (STILL IN EFFECT)
-
-- Use step-by-step reasoning unless explicitly instructed not to.
-- Prioritize correctness, clarity, and concise execution.
-- Be brutally honest when asked — no sugarcoating or vague optimism.
-- Always ask, “Am I missing something?” after completing a task.
-
----------------------------------------------
-POSSIBLE BLIND SPOTS / NEXT STEPS
----------------------------------------------
-
-- Ensure every tool has an explicit and validated output schema.
-- Review tool naming for consistency with the required convention.
-- Add schema validation to downstream consumers if not yet implemented.
-- Eliminate or refactor any tools not listed in the approved set above.
-
-No based on my instructions I need a tool for the following TASK :
-
-**{task}
-
-Return only the JSON object that represents the tool specification—no extra text, comments, or keys outside the schema.
- """
-    
-
-    print(prompt)
-    data = {
-        "messages": [
-            {"role": "system", "content": "All tool invocation results must be returned in JSON format only. Do not add extra text, commentary, or non‑JSON content"},
-            {"role": "user", "content": prompt},
-        ],
-        "model": "tools",
-        "stream": False,
-        "temperature": 0.3,
-    }
-
-    content = None
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        response.raise_for_status()
-        content = response.json()["choices"][0]["message"]["content"]
-        
-        print("-----------------")
-        print(content)
-        print("-----------------")
-        return content
-    except Exception as e:
-        return f"Error: {e}"
+app = FastAPI()
 
+mcp = FastApiMCP(app)
 
+# Mount the MCP server directly to your FastAPI app
+mcp.mount()