Update app.py

app.py

@@ -1,9 +1,440 @@
-from fastapi import FastAPI
-from fastapi_mcp import FastApiMCP
+from fastmcp import FastMCP
+import requests
 
-app = FastAPI()
+# Step 1: Create the server
+mcp = FastMCP(name="MCP Server with Standardized Tools")
 
-mcp = FastApiMCP(app)
 
-# Mount the MCP server directly to your FastAPI app
-mcp.mount()
+# 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}"
+
+
+# Step 5: Make the server runnable
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=7860, path="/mcp")