iflow-mcp_sker65-testrail-mcp 0.1.5__py3-none-any.whl

iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_sker65-testrail-mcp
+Version: 0.1.5
+Summary: TestRail MCP Server
+Author-email: Stefan Rinke <sker65@gmail.com>
+Maintainer-email: Stefan Rinke <sker65@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: fastmcp
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: python-mcp>=1.0.0
+Requires-Dist: requests>=2.31.0
+Description-Content-Type: text/markdown
+
+# TestRail MCP Server
+
+[![smithery badge](https://smithery.ai/badge/@sker65/testrail-mcp)](https://smithery.ai/server/@sker65/testrail-mcp)
+
+A Model Context Protocol (MCP) server for TestRail that allows interaction with TestRail's core entities through a standardized protocol.
+
+## Features
+
+- Authentication with TestRail API
+- Access to TestRail entities:
+  - Projects
+  - Cases
+  - Runs
+  - Results
+  - Datasets
+- Full support for the Model Context Protocol
+- Compatible with any MCP client (Claude Desktop, Cursor, Windsurf, etc.)
+
+## See it in action together with Octomind MCP
+
+[![Video Title](https://img.youtube.com/vi/I7lc9I0S62Y/0.jpg)](https://www.youtube.com/watch?v=I7lc9I0S62Y)
+
+## Installation
+
+### Installing via Smithery
+
+To install testrail-mcp for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@sker65/testrail-mcp):
+
+```bash
+npx -y @smithery/cli install @sker65/testrail-mcp --client claude
+```
+
+### Manual Installation
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/yourusername/testrail-mcp.git
+   cd testrail-mcp
+   ```
+
+2. Create and activate a virtual environment:
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+   ```
+
+3. Install dependencies:
+   ```bash
+   pip install -e .
+   ```
+
+## Configuration
+
+The TestRail MCP server requires specific environment variables to authenticate with your TestRail instance. These must be set before running the server.
+
+1. Create a `.env` file in the root directory of the project:
+   ```
+   TESTRAIL_URL=https://your-instance.testrail.io
+   TESTRAIL_USERNAME=your-email@example.com
+   TESTRAIL_API_KEY=your-api-key
+   ```
+
+   **Important Notes:**
+   - `TESTRAIL_URL` should be the full URL to your TestRail instance (e.g., `https://example.testrail.io`)
+   - `TESTRAIL_USERNAME` is your TestRail email address used for login
+   - `TESTRAIL_API_KEY` is your TestRail API key (not your password)
+     - To generate an API key, log in to TestRail, go to "My Settings" > "API Keys" and create a new key
+
+2. Verify that the configuration is loaded correctly:
+   ```bash
+   uvx testrail-mcp --config
+   ```
+   
+   This will display your TestRail configuration information, including your URL, username, and the first few characters of your API key for verification.
+
+If you're using this server with a client like Claude Desktop or Cursor, make sure the environment variables are accessible to the process running the server. You may need to set these variables in your system environment or ensure they're loaded from the `.env` file.
+
+## Usage
+
+### Running the Server
+
+The server can be run directly using the installed script:
+
+```bash
+uvx testrail-mcp
+```
+
+This will start the MCP server in stdio mode, which can be used with MCP clients that support stdio communication.
+
+### Using with MCP Clients
+
+#### Claude Desktop
+
+In Claude Desktop, add a new server with the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "testrail": {
+      "command": "uvx",
+      "args": [
+        "testrail-mcp"
+      ],
+      "env": {
+        "TESTRAIL_URL": "https://your-instance.testrail.io",
+        "TESTRAIL_USERNAME": "your-email@example.com",
+        "TESTRAIL_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+#### Cursor
+
+In Cursor, add a new custom tool with the following configuration:
+
+```json
+{
+  "name": "TestRail MCP",
+  "command": "uvx",
+  "args": [
+    "testrail-mcp"
+  ],
+  "env": {
+    "TESTRAIL_URL": "https://your-instance.testrail.io",
+    "TESTRAIL_USERNAME": "your-email@example.com",
+    "TESTRAIL_API_KEY": "your-api-key"
+  }
+}
+```
+
+#### Windsurf
+
+In Windsurf, add a new tool with the following configuration:
+
+```json
+{
+  "name": "TestRail MCP",
+  "command": "uvx",
+  "args": [
+    "testrail-mcp"
+  ],
+  "env": {
+    "TESTRAIL_URL": "https://your-instance.testrail.io",
+    "TESTRAIL_USERNAME": "your-email@example.com",
+    "TESTRAIL_API_KEY": "your-api-key"
+  }
+}
+```
+
+#### Testing with MCP Inspector
+
+For testing and debugging, you can use the MCP Inspector:
+
+```bash
+npx @modelcontextprotocol/inspector \
+  -e TESTRAIL_URL=<your-url> \
+  -e TESTRAIL_USERNAME=<your-username> \
+  -e TESTRAIL_API_KEY=<your-api-key> \
+  uvx testrail-mcp
+```
+
+This will open a web interface where you can explore and test all the available tools and resources.
+
+## Development
+
+This server is built using:
+
+- [FastMCP](https://github.com/jlowin/fastmcp) - A Python framework for building MCP servers
+- [Requests](https://requests.readthedocs.io/) - For HTTP communication with TestRail API
+- [python-dotenv](https://github.com/theskumar/python-dotenv) - For environment variable management
+
+## License
+
+MIT

iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+testrail_mcp/__init__.py,sha256=qD-ToZHGgYbGVwzdH4IK2-mrL9DOnGL4VhagARVnhYg,34
+testrail_mcp/__main__.py,sha256=BlQY356TPrUV7W-LH6CfA_vNv6jKlY1r-FU-P8gABaw,388
+testrail_mcp/config.py,sha256=iZ-pp7Ihy3-nIhawusVW675NtYtmpuMFwBGKV62-SV0,578
+testrail_mcp/mcp_server.py,sha256=k2Dl9muaVsjIsu9wmEjfQD9CbEgMGiJ_7iOwVzfqlW4,25959
+testrail_mcp/testrail_client.py,sha256=0MoRDVt6UQoFsUURlmeDr2TWOViNqnhDZyqRDWNTLNY,8613
+iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/METADATA,sha256=HOzp6FsHyiZ_CSy1pbS3xj8UD3oHPPEkc29Lwsheo4M,5097
+iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/entry_points.txt,sha256=0ApB6a60n2oBb9s6d5iP5EbRYinxec0BXSQQ1xz5rEI,60
+iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/licenses/LICENSE,sha256=RLjrd9J2YCGMaJtvLLWONAd_mVmcZscQKmIM2bQMBRw,1069
+iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/RECORD,,

iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+testrail-mcp = testrail_mcp.__main__:main

iflow_mcp_sker65_testrail_mcp-0.1.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Stefan Rinke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

testrail_mcp/__init__.py

@@ -0,0 +1 @@
+"""TestRail MCP server package."""

testrail_mcp/__main__.py

@@ -0,0 +1,14 @@
+"""Entry point for the TestRail MCP server when run as a module."""
+import sys
+import asyncio
+
+from testrail_mcp.mcp_server import TestRailMCPServer
+
+def main():
+    """Run the TestRail MCP server."""
+    print("Starting TestRail MCP server in stdio mode", file=sys.stderr)
+    server = TestRailMCPServer()
+    asyncio.run(server.run_stdio_async())
+
+if __name__ == "__main__":
+    main()

testrail_mcp/config.py

@@ -0,0 +1,18 @@
+"""Configuration module for TestRail MCP server."""
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# TestRail configuration
+TESTRAIL_URL = os.getenv('TESTRAIL_URL')
+TESTRAIL_USERNAME = os.getenv('TESTRAIL_USERNAME')
+TESTRAIL_API_KEY = os.getenv('TESTRAIL_API_KEY')
+
+# Validate configuration
+if not all([TESTRAIL_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY]):
+    raise ValueError(
+        "Missing TestRail configuration. Please set TESTRAIL_URL, "
+        "TESTRAIL_USERNAME, and TESTRAIL_API_KEY environment variables."
+    )

testrail_mcp/mcp_server.py

@@ -0,0 +1,645 @@
+"""MCP server implementation for TestRail."""
+from typing import Dict, List, Any, Optional, Union
+from fastmcp import FastMCP
+
+from testrail_mcp.testrail_client import TestRailClient
+from testrail_mcp.config import TESTRAIL_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY
+
+
+class TestRailMCPServer(FastMCP):
+    """MCP server for TestRail integration using FastMCP."""
+    
+    def __init__(self):
+        """Initialize the TestRail MCP server."""
+        super().__init__(name="TestRail MCP Server", version="0.1.3")
+        self.client = TestRailClient(TESTRAIL_URL, TESTRAIL_USERNAME, TESTRAIL_API_KEY)
+        self._register_tools()
+        self._register_resources()
+    
+    def _register_tools(self):
+        """Register all TestRail tools with the MCP server."""
+        # Project tools
+        @self.tool("get_project", description="Get a project by ID")
+        def get_project(project_id: int) -> Dict:
+            """Get a project by ID."""
+            return self.client.get_project(project_id)
+        
+        @self.tool("get_projects", description="Get all projects")
+        def get_projects() -> List[Dict]:
+            """Get all projects."""
+            return self.client.get_projects()
+        
+        @self.tool("add_project", description="Add a new project")
+        def add_project(
+            name: str,
+            announcement: Optional[str] = None,
+            show_announcement: Optional[bool] = None,
+            suite_mode: Optional[int] = None
+        ) -> Dict:
+            """
+            Add a new project.
+            
+            Args:
+                name: The name of the project
+                announcement: The announcement of the project (optional)
+                show_announcement: Whether to show the announcement (optional)
+                suite_mode: The suite mode: 1 for single suite mode, 2 for single suite + baselines, 3 for multiple suites (optional)
+            """
+            data = {'name': name}
+            if announcement is not None:
+                data['announcement'] = announcement
+            if show_announcement is not None:
+                data['show_announcement'] = show_announcement
+            if suite_mode is not None:
+                data['suite_mode'] = suite_mode
+            return self.client.add_project(data)
+        
+        @self.tool("update_project", description="Update an existing project")
+        def update_project(
+            project_id: int,
+            name: Optional[str] = None,
+            announcement: Optional[str] = None,
+            show_announcement: Optional[bool] = None,
+            is_completed: Optional[bool] = None
+        ) -> Dict:
+            """
+            Update an existing project.
+            
+            Args:
+                project_id: The ID of the project
+                name: The name of the project (optional)
+                announcement: The announcement of the project (optional)
+                show_announcement: Whether to show the announcement (optional)
+                is_completed: Whether the project is completed (optional)
+            """
+            data = {}
+            if name is not None:
+                data['name'] = name
+            if announcement is not None:
+                data['announcement'] = announcement
+            if show_announcement is not None:
+                data['show_announcement'] = show_announcement
+            if is_completed is not None:
+                data['is_completed'] = is_completed
+            return self.client.update_project(project_id, data)
+        
+        @self.tool("delete_project", description="Delete a project")
+        def delete_project(project_id: int) -> Dict:
+            """
+            Delete a project.
+            
+            Args:
+                project_id: The ID of the project
+            """
+            return self.client.delete_project(project_id)
+        
+        # Case tools
+        @self.tool("get_case", description="Get a test case by ID")
+        def get_case(case_id: int) -> Dict:
+            """
+            Get a test case by ID.
+            
+            Args:
+                case_id: The ID of the test case
+            """
+            return self.client.get_case(case_id)
+        
+        @self.tool("get_cases", description="Get all test cases for a project/suite")
+        def get_cases(project_id: int, suite_id: Optional[int] = None) -> List[Dict]:
+            """
+            Get all test cases for a project/suite.
+            
+            Args:
+                project_id: The ID of the project
+                suite_id: The ID of the test suite (optional)
+            """
+            return self.client.get_cases(project_id, suite_id)
+        
+        @self.tool("add_case", description="Add a new test case")
+        def add_case(
+            section_id: int,
+            title: str,
+            type_id: Optional[int] = None,
+            priority_id: Optional[int] = None,
+            estimate: Optional[str] = None,
+            milestone_id: Optional[int] = None,
+            refs: Optional[str] = None,
+            custom_steps: Optional[str] = None,
+            custom_expected: Optional[str] = None,
+            custom_steps_separated: Optional[List[Dict[str, str]]] = None,
+            steps_separated: Optional[List[Dict[str, str]]] = None
+        ) -> Dict:
+            """
+            Add a new test case.
+            
+            Args:
+                section_id: The ID of the section
+                title: The title of the test case
+                type_id: The ID of the case type (optional)
+                priority_id: The ID of the priority (optional)
+                estimate: The estimate, e.g. '30s' or '1m 45s' (optional)
+                milestone_id: The ID of the milestone (optional)
+                refs: A comma-separated list of references (optional)
+                custom_steps: Steps as string
+                custom_expected: case expected result
+                custom_steps_separated: A list of test steps (optional), each with fields:
+                    - content: The text contents of the "Step" field
+                    - expected: The text contents of the "Expected Result" field
+                    - additional_info: The text contents of the "Additional Info" field
+                    - refs: Reference information for the "References" field
+                steps_separated: A list of test steps (optional), each with fields:
+                    - content: The text contents of the "Step" field
+                    - expected: The text contents of the "Expected Result" field
+                    - additional_info: The text contents of the "Additional Info" field
+                    - refs: Reference information for the "References" field
+            """
+            data = {'title': title}
+            if type_id is not None:
+                data['type_id'] = type_id
+            if priority_id is not None:
+                data['priority_id'] = priority_id
+            if estimate is not None:
+                data['estimate'] = estimate
+            if milestone_id is not None:
+                data['milestone_id'] = milestone_id
+            if refs is not None:
+                data['refs'] = refs
+            if custom_steps_separated is not None:
+                data['custom_steps_separated'] = custom_steps_separated
+            if steps_separated is not None:
+                data['steps_separated'] = steps_separated
+            if custom_steps is not None:
+                data['custom_steps'] = custom_steps
+            if custom_expected is not None:
+                data['custom_expected'] = custom_expected
+            return self.client.add_case(section_id, data)
+        
+        @self.tool("update_case", description="Update an existing test case")
+        def update_case(
+            case_id: int,
+            title: Optional[str] = None,
+            type_id: Optional[int] = None,
+            priority_id: Optional[int] = None,
+            estimate: Optional[str] = None,
+            milestone_id: Optional[int] = None,
+            refs: Optional[str] = None,
+            custom_steps: Optional[str] = None,
+            custom_expected: Optional[str] = None,
+            custom_steps_separated: Optional[List[Dict[str, str]]] = None,
+            steps_separated: Optional[List[Dict[str, str]]] = None
+        ) -> Dict:
+            """
+            Update an existing test case.
+            
+            Args:
+                case_id: The ID of the test case
+                title: The title of the test case (optional)
+                type_id: The ID of the case type (optional)
+                priority_id: The ID of the priority (optional)
+                estimate: The estimate, e.g. '30s' or '1m 45s' (optional)
+                milestone_id: The ID of the milestone (optional)
+                refs: A comma-separated list of references (optional)
+                custom_expected: case expected result
+                custom_steps_separated: A list of test steps (optional), each with fields:
+                    - content: The text contents of the "Step" field
+                    - expected: The text contents of the "Expected Result" field
+                    - additional_info: The text contents of the "Additional Info" field
+                    - refs: Reference information for the "References" field
+                steps_separated: A list of test steps (optional), each with fields:
+                    - content: The text contents of the "Step" field
+                    - expected: The text contents of the "Expected Result" field
+                    - additional_info: The text contents of the "Additional Info" field
+                    - refs: Reference information for the "References" field
+            """
+            data = {}
+            if title is not None:
+                data['title'] = title
+            if type_id is not None:
+                data['type_id'] = type_id
+            if priority_id is not None:
+                data['priority_id'] = priority_id
+            if estimate is not None:
+                data['estimate'] = estimate
+            if milestone_id is not None:
+                data['milestone_id'] = milestone_id
+            if refs is not None:
+                data['refs'] = refs
+            if custom_steps_separated is not None:
+                data['custom_steps_separated'] = custom_steps_separated
+            if steps_separated is not None:
+                data['steps_separated'] = steps_separated
+            if custom_steps is not None:
+                data['custom_steps'] = custom_steps
+            if custom_expected is not None:
+                data['custom_expected'] = custom_expected
+            return self.client.update_case(case_id, data)
+        
+        @self.tool("delete_case", description="Delete a test case")
+        def delete_case(case_id: int) -> Dict:
+            """
+            Delete a test case.
+            
+            Args:
+                case_id: The ID of the test case
+            """
+            return self.client.delete_case(case_id)
+        # Section tools
+        @self.tool("get_section", description="Retrieves details of a specific section by ID")
+        def get_section(section_id: int) -> Dict:
+            """
+            Get a section by ID.
+            
+            Args:
+                section_id: The ID of the section
+            """
+            return self.client.get_section(section_id)
+
+        @self.tool("get_sections", description="Retrieves all sections for a specified project and or suite")
+        def get_sections(
+            project_id : int,
+            suite_id: Optional[int] = None ) -> Dict:
+            """
+            Retrieves all sections for a specified project and suite
+            
+            Args:
+                project_id: The ID of the project
+                suite_id: The ID of the test suite (Optional)
+
+            """
+            return self.client.get_sections(project_id,suite_id)
+
+        @self.tool("add_section", description="Creates a new section in a TestRail project")
+        def add_section(
+            project_id : int,
+            name: str,
+            description: str,
+            suite_id: Optional[int] = None,
+            parent_id: Optional[int] = None) -> Dict:
+            """
+            Retrieves all sections for a specified project and suite
+            
+            Args:
+                project_id: The ID of the project
+                name: Name of the section
+                description: Description of the section
+                suite_id: The ID of the test suite (Optional)
+                parent_id: The ID of the parent
+
+            """
+            data = {}
+            data["name"] = name
+            data["description"] = description
+            if suite_id is not None:
+                data["suite_id"] = suite_id
+            if parent_id is not None:
+                data["parent_id"] = parent_id
+
+            return self.client.add_section(project_id,data)
+
+        @self.tool("update_section", description="Updates an existing section")
+        def update_section(
+            section_id : int,
+            name: Optional[str] = None,
+            description: Optional[str] = None) -> Dict:
+            """
+            Updates an existing section
+            
+            Args:
+                section_id: The ID of the section
+                name: Name of the section
+                description: Description of the section
+            """
+            data = {}
+            if name is not None:
+                data["name"] = name
+            if description is not None:
+                data["description"] = description
+
+            return self.client.update_section(section_id, data)
+
+        @self.tool("delete_section", description="Deletes a section")
+        def delete_section(
+            section_id : int,
+            soft: bool) -> Dict:
+            """
+            Deletes an existing section
+            
+            Args:
+                section_id: The ID of the section
+                soft: Omitting the soft parameter, or submitting soft=0 will delete the section and its test cases If soft=1, this will return data on the number of affected tests, cases, etc.
+            """
+
+            return self.client.delete_section(section_id, soft)
+
+        @self.tool("move_section", description="Moves a section to a new position in the test hierarchy")
+        def move_section(
+            section_id : int,
+            parent_id : Optional[int],
+            after_id : Optional[int]) -> Dict:
+            """
+            Moves a section to a new position in the test hierarchy
+            
+            Args:
+                section_id: The ID of the section
+                parent_id: ID of the new parent
+                after_id: ID of the section to be moved after
+            """
+            data = {}
+            if parent_id is not None:
+                data["parent_id"] = parent_id
+            if after_id is not None:
+                data["after_id"] = after_id
+
+            return self.client.move_section(section_id, data)
+
+        # Run tools
+        @self.tool("get_run", description="Get a test run by ID")
+        def get_run(run_id: int) -> Dict:
+            """
+            Get a test run by ID.
+            
+            Args:
+                run_id: The ID of the test run
+            """
+            return self.client.get_run(run_id)
+        
+        @self.tool("get_runs", description="Get all test runs for a project")
+        def get_runs(project_id: int) -> List[Dict]:
+            """
+            Get all test runs for a project.
+            
+            Args:
+                project_id: The ID of the project
+            """
+            return self.client.get_runs(project_id)
+        
+        @self.tool("add_run", description="Add a new test run")
+        def add_run(
+            project_id: int,
+            suite_id: int,
+            name: str,
+            description: Optional[str] = None,
+            milestone_id: Optional[int] = None,
+            assignedto_id: Optional[int] = None,
+            include_all: Optional[bool] = None,
+            case_ids: Optional[List[int]] = None
+        ) -> Dict:
+            """
+            Add a new test run.
+            
+            Args:
+                project_id: The ID of the project
+                suite_id: The ID of the test suite
+                name: The name of the test run
+                description: The description of the test run (optional)
+                milestone_id: The ID of the milestone (optional)
+                assignedto_id: The ID of the user the test run should be assigned to (optional)
+                include_all: True for including all test cases of the test suite and false for a custom case selection (default: true) (optional)
+                case_ids: An array of case IDs for the custom case selection (optional)
+            """
+            data = {
+                'suite_id': suite_id,
+                'name': name
+            }
+            if description is not None:
+                data['description'] = description
+            if milestone_id is not None:
+                data['milestone_id'] = milestone_id
+            if assignedto_id is not None:
+                data['assignedto_id'] = assignedto_id
+            if include_all is not None:
+                data['include_all'] = include_all
+            if case_ids is not None:
+                data['case_ids'] = case_ids
+            return self.client.add_run(project_id, data)
+        
+        @self.tool("update_run", description="Update an existing test run")
+        def update_run(
+            run_id: int,
+            name: Optional[str] = None,
+            description: Optional[str] = None,
+            milestone_id: Optional[int] = None,
+            assignedto_id: Optional[int] = None,
+            include_all: Optional[bool] = None,
+            case_ids: Optional[List[int]] = None
+        ) -> Dict:
+            """
+            Update an existing test run.
+            
+            Args:
+                run_id: The ID of the test run
+                name: The name of the test run (optional)
+                description: The description of the test run (optional)
+                milestone_id: The ID of the milestone (optional)
+                assignedto_id: The ID of the user the test run should be assigned to (optional)
+                include_all: True for including all test cases of the test suite and false for a custom case selection (default: true) (optional)
+                case_ids: An array of case IDs for the custom case selection (optional)
+            """
+            data = {}
+            if name is not None:
+                data['name'] = name
+            if description is not None:
+                data['description'] = description
+            if milestone_id is not None:
+                data['milestone_id'] = milestone_id
+            if assignedto_id is not None:
+                data['assignedto_id'] = assignedto_id
+            if include_all is not None:
+                data['include_all'] = include_all
+            if case_ids is not None:
+                data['case_ids'] = case_ids
+            return self.client.update_run(run_id, data)
+        
+        @self.tool("close_run", description="Close an existing test run")
+        def close_run(run_id: int) -> Dict:
+            """
+            Close an existing test run.
+            
+            Args:
+                run_id: The ID of the test run
+            """
+            return self.client.close_run(run_id)
+        
+        @self.tool("delete_run", description="Delete a test run")
+        def delete_run(run_id: int) -> Dict:
+            """
+            Delete a test run.
+            
+            Args:
+                run_id: The ID of the test run
+            """
+            return self.client.delete_run(run_id)
+        
+        # Results tools
+        @self.tool("get_results", description="Get all test results for a test")
+        def get_results(test_id: int) -> List[Dict]:
+            """
+            Get all test results for a test.
+            
+            Args:
+                test_id: The ID of the test
+            """
+            return self.client.get_results(test_id)
+        
+        @self.tool("add_result", description="Add a new test result")
+        def add_result(
+            test_id: int,
+            status_id: int,
+            comment: Optional[str] = None,
+            version: Optional[str] = None,
+            elapsed: Optional[str] = None,
+            defects: Optional[str] = None,
+            assignedto_id: Optional[int] = None
+        ) -> Dict:
+            """
+            Add a new test result.
+            
+            Args:
+                test_id: The ID of the test
+                status_id: The ID of the test status
+                comment: The comment / description for the test result (optional)
+                version: The version or build you tested against (optional)
+                elapsed: The time it took to execute the test, e.g. '30s' or '1m 45s' (optional)
+                defects: A comma-separated list of defects to link to the test result (optional)
+                assignedto_id: The ID of a user the test should be assigned to (optional)
+            """
+            data = {
+                'status_id': status_id
+            }
+            if comment is not None:
+                data['comment'] = comment
+            if version is not None:
+                data['version'] = version
+            if elapsed is not None:
+                data['elapsed'] = elapsed
+            if defects is not None:
+                data['defects'] = defects
+            if assignedto_id is not None:
+                data['assignedto_id'] = assignedto_id
+            return self.client.add_result(test_id, data)
+        
+        # Dataset tools
+        @self.tool("get_dataset", description="Get a dataset by ID")
+        def get_dataset(dataset_id: int) -> Dict:
+            """
+            Get a dataset by ID.
+            
+            Args:
+                dataset_id: The ID of the dataset
+            """
+            return self.client.get_dataset(dataset_id)
+        
+        @self.tool("get_datasets", description="Get all datasets for a project")
+        def get_datasets(project_id: int) -> List[Dict]:
+            """
+            Get all datasets for a project.
+            
+            Args:
+                project_id: The ID of the project
+            """
+            return self.client.get_datasets(project_id)
+        
+        @self.tool("add_dataset", description="Add a new dataset")
+        def add_dataset(
+            project_id: int,
+            name: str,
+            description: Optional[str] = None
+        ) -> Dict:
+            """
+            Add a new dataset.
+            
+            Args:
+                project_id: The ID of the project
+                name: The name of the dataset
+                description: The description of the dataset (optional)
+            """
+            data = {
+                'name': name
+            }
+            if description is not None:
+                data['description'] = description
+            return self.client.add_dataset(project_id, data)
+        
+        @self.tool("update_dataset", description="Update an existing dataset")
+        def update_dataset(
+            dataset_id: int,
+            name: Optional[str] = None,
+            description: Optional[str] = None
+        ) -> Dict:
+            """
+            Update an existing dataset.
+            
+            Args:
+                dataset_id: The ID of the dataset
+                name: The name of the dataset (optional)
+                description: The description of the dataset (optional)
+            """
+            data = {}
+            if name is not None:
+                data['name'] = name
+            if description is not None:
+                data['description'] = description
+            return self.client.update_dataset(dataset_id, data)
+        
+        @self.tool("delete_dataset", description="Delete a dataset")
+        def delete_dataset(dataset_id: int) -> Dict:
+            """
+            Delete a dataset.
+            
+            Args:
+                dataset_id: The ID of the dataset
+            """
+            return self.client.delete_dataset(dataset_id)
+    
+    def _register_resources(self):
+        """Register all TestRail resources with the MCP server."""
+        @self.resource("testrail://project/{project_id}")
+        def get_project_resource(project_id: int) -> Dict:
+            """
+            Get a project by ID.
+            
+            Args:
+                project_id: The ID of the project
+            """
+            return self.client.get_project(project_id)
+        
+        @self.resource("testrail://case/{case_id}")
+        def get_case_resource(case_id: int) -> Dict:
+            """
+            Get a test case by ID.
+            
+            Args:
+                case_id: The ID of the test case
+            """
+            return self.client.get_case(case_id)
+        
+        @self.resource("testrail://run/{run_id}")
+        def get_run_resource(run_id: int) -> Dict:
+            """
+            Get a test run by ID.
+            
+            Args:
+                run_id: The ID of the test run
+            """
+            return self.client.get_run(run_id)
+        
+        @self.resource("testrail://results/{test_id}")
+        def get_results_resource(test_id: int) -> List[Dict]:
+            """
+            Get all test results for a test.
+            
+            Args:
+                test_id: The ID of the test
+            """
+            return self.client.get_results(test_id)
+        
+        @self.resource("testrail://dataset/{dataset_id}")
+        def get_dataset_resource(dataset_id: int) -> Dict:
+            """
+            Get a dataset by ID.
+            
+            Args:
+                dataset_id: The ID of the dataset
+            """
+            return self.client.get_dataset(dataset_id)
+

testrail_mcp/testrail_client.py

@@ -0,0 +1,216 @@
+"""TestRail API client module."""
+import base64
+import json
+from typing import Dict, List, Any, Optional, Union
+import requests
+
+class TestRailClient:
+    """TestRail API client for interacting with TestRail."""
+
+    def __init__(self, base_url: str, username: str, api_key: str):
+        """
+        Initialize the TestRail API client.
+        
+        Args:
+            base_url: The URL of your TestRail instance (e.g., [https://example.testrail.io/)](https://example.testrail.io/))
+            username: Your TestRail username/email
+            api_key: Your TestRail API key
+        """
+        self.username = username
+        self.api_key = api_key
+        
+        # Ensure the base URL ends with a slash
+        if not base_url.endswith('/'):
+            base_url += '/'
+        self.base_url = base_url + 'index.php?/api/v2/'
+        
+        # Set up the session with authentication
+        self.session = requests.Session()
+        auth = str(
+            base64.b64encode(
+                bytes(f'{username}:{api_key}', 'utf-8')
+            ),
+            'ascii'
+        ).strip()
+        self.session.headers.update({
+            'Authorization': f'Basic {auth}',
+            'Content-Type': 'application/json',
+        })
+
+    def _send_request(self, method: str, uri: str, data: Optional[Dict] = None) -> Any:
+        """
+        Send a request to the TestRail API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            uri: API endpoint URI
+            data: Request data for POST/PUT requests
+            
+        Returns:
+            Response data from TestRail
+            
+        Raises:
+            Exception: If the request fails
+        """
+        url = self.base_url + uri
+        
+        if method.upper() == 'GET':
+            response = self.session.get(url)
+        elif method.upper() == 'POST':
+            response = self.session.post(url, data=json.dumps(data) if data else None)
+        elif method.upper() == 'PUT':
+            response = self.session.put(url, data=json.dumps(data) if data else None)
+        elif method.upper() == 'DELETE':
+            response = self.session.delete(url)
+        else:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+            
+        if response.status_code >= 300:
+            try:
+                error = response.json()
+            except:
+                error = response.text
+            raise Exception(f"TestRail API returned HTTP {response.status_code}: {error}")
+            
+        return response.json() if response.content else {}
+
+    # Cases API
+    def get_case(self, case_id: int) -> Dict:
+        """Get a test case by ID."""
+        return self._send_request('GET', f'get_case/{case_id}')
+    
+    def get_cases(self, project_id: int, suite_id: Optional[int] = None) -> List[Dict]:
+        """Get all test cases for a project/suite."""
+        uri = f'get_cases/{project_id}'
+        if suite_id:
+            uri += f'&suite_id={suite_id}'
+        return self._send_request('GET', uri)
+    
+    def add_case(self, section_id: int, data: Dict) -> Dict:
+        """Add a new test case."""
+        return self._send_request('POST', f'add_case/{section_id}', data)
+    
+    def update_case(self, case_id: int, data: Dict) -> Dict:
+        """Update an existing test case."""
+        return self._send_request('POST', f'update_case/{case_id}', data)
+    
+    def delete_case(self, case_id: int) -> Dict:
+        """Delete a test case."""
+        return self._send_request('POST', f'delete_case/{case_id}')
+    
+    # Projects API
+    def get_project(self, project_id: int) -> Dict:
+        """Get a project by ID."""
+        return self._send_request('GET', f'get_project/{project_id}')
+    
+    def get_projects(self) -> List[Dict]:
+        """Get all projects."""
+        return self._send_request('GET', 'get_projects')
+    
+    def add_project(self, data: Dict) -> Dict:
+        """Add a new project."""
+        return self._send_request('POST', 'add_project', data)
+    
+    def update_project(self, project_id: int, data: Dict) -> Dict:
+        """Update an existing project."""
+        return self._send_request('POST', f'update_project/{project_id}', data)
+    
+    def delete_project(self, project_id: int) -> Dict:
+        """Delete a project."""
+        return self._send_request('POST', f'delete_project/{project_id}')
+    
+    # Runs API
+    def get_run(self, run_id: int) -> Dict:
+        """Get a test run by ID."""
+        return self._send_request('GET', f'get_run/{run_id}')
+    
+    def get_runs(self, project_id: int) -> List[Dict]:
+        """Get all test runs for a project."""
+        return self._send_request('GET', f'get_runs/{project_id}')
+    
+    def add_run(self, project_id: int, data: Dict) -> Dict:
+        """Add a new test run."""
+        return self._send_request('POST', f'add_run/{project_id}', data)
+    
+    def update_run(self, run_id: int, data: Dict) -> Dict:
+        """Update an existing test run."""
+        return self._send_request('POST', f'update_run/{run_id}', data)
+    
+    def close_run(self, run_id: int) -> Dict:
+        """Close a test run."""
+        return self._send_request('POST', f'close_run/{run_id}')
+    
+    def delete_run(self, run_id: int) -> Dict:
+        """Delete a test run."""
+        return self._send_request('POST', f'delete_run/{run_id}')
+    
+    # Results API
+    def get_results(self, test_id: int) -> List[Dict]:
+        """Get all results for a test."""
+        return self._send_request('GET', f'get_results/{test_id}')
+    
+    def get_results_for_run(self, run_id: int) -> List[Dict]:
+        """Get all results for a run."""
+        return self._send_request('GET', f'get_results_for_run/{run_id}')
+    
+    def add_result(self, test_id: int, data: Dict) -> Dict:
+        """Add a new result for a test."""
+        return self._send_request('POST', f'add_result/{test_id}', data)
+    
+    def add_results(self, run_id: int, data: Dict) -> List[Dict]:
+        """Add multiple results for a run."""
+        return self._send_request('POST', f'add_results/{run_id}', data)
+    
+    def add_results_for_cases(self, run_id: int, data: Dict) -> List[Dict]:
+        """Add results for specific cases in a run."""
+        return self._send_request('POST', f'add_results_for_cases/{run_id}', data)
+    
+    # Datasets API (assuming TestRail has dataset endpoints)
+    def get_datasets(self, project_id: int) -> List[Dict]:
+        """Get all datasets for a project."""
+        return self._send_request('GET', f'get_datasets/{project_id}')
+    
+    def get_dataset(self, dataset_id: int) -> Dict:
+        """Get a dataset by ID."""
+        return self._send_request('GET', f'get_dataset/{dataset_id}')
+    
+    def add_dataset(self, project_id: int, data: Dict) -> Dict:
+        """Add a new dataset."""
+        return self._send_request('POST', f'add_dataset/{project_id}', data)
+    
+    def update_dataset(self, dataset_id: int, data: Dict) -> Dict:
+        """Update an existing dataset."""
+        return self._send_request('POST', f'update_dataset/{dataset_id}', data)
+    
+    def delete_dataset(self, dataset_id: int) -> Dict:
+        """Delete a dataset."""
+        return self._send_request('POST', f'delete_dataset/{dataset_id}')
+
+    # Sections API
+    def get_section(self, section_id:int) -> Dict:
+        """Get a specific section"""
+        return self._send_request('GET', f'get_section/{section_id}')
+
+    def get_sections(self, project_id: int, suite_id:Optional[int] = None, params:Optional[Dict] = None) -> Dict:
+        """Get all sections for a project"""
+        query_params = {**params, "suite_id": suite_id} if suite_id else params
+        return self._send_request('GET', f'get_sections/{project_id}',{params : query_params})
+
+    def add_section(self, project_id:int, data:Dict) -> Dict:
+        """Add a new section"""
+        return self._send_request('POST', f'add_section/{project_id}', data)
+
+    def update_section(self, section_id:int, data:Dict) -> Dict:
+        """Update an existing section"""
+        return self._send_request('POST', f'update_section/{section_id}', data)
+
+    def delete_section(self, section_id:int, soft:bool) -> Dict:
+        """Delete an existing section"""
+        url = f'delete_section/{section_id}'
+        if (soft):
+            url = f'delete_section/{section_id}?soft=1'
+        return self._send_request('POST', url)
+
+    def move_section(self, section_id:int, data: Dict) -> Dict:
+        """Move a section to a different parent or position"""
+        return self._send_request('POST', f'move_section/{section_id}', data)