MCP Xray Python

🚀 QA Autopilot: A Model Context Protocol (MCP) for Jira and Gemini

A Command Line Interface (CLI) tool that implements the concept of Model Context Protocol (MCP). This tool serves as a bridge connecting Jira (as a knowledge server) with Google Gemini (via Vertex AI) for test case generation.

The Analogy: The Autopilot

As a commercial pilot, I know that the autopilot doesn't fly the plane alone. The pilot remains in control: monitoring systems, managing the flight plan, and making critical decisions. The autopilot handles the heavy and repetitive work, allowing the pilot to focus on the strategic aspects.

This project applies the same principle to Quality Assurance.

What's the Problem?

Manually creating test cases in Jira is one of the most necessary yet tedious tasks in the software lifecycle. It consumes valuable time that QA analysts could spend on higher - impact tasks such as exploratory testing, automation strategy design, or complex risk analysis.

The Solution: "QA Autopilot" as an MCP

Inspired by the concept of Model Context Protocol (MCP) — which enables models to connect to knowledge servers — this tool doesn't aim to replace the QA analyst but to empower them.

It acts as an intelligent bridge that can be executed with a single command:

• Receives a Jira User Story (US) ID from the terminal.
• Acts as an MCP: Connects to the Jira API (the "knowledge server") to extract the full context (description, acceptance criteria).
• Queries the Model: Sends that context to Google Gemini with a QA prompt.
• Generates a detailed set of test cases (in Gherkin format).
• Automatically creates "Test" issues in Jira/Xray and links them to the original US.

The result: Instead of spending hours writing test cases (TCs), the QA analyst (the "pilot") only needs to review, adjust, and approve the generated TCs, saving a significant amount of time and effort.

Architecture and Workflow

The application's workflow is as follows:

1. Start: A user (QA Analyst) runs the run_mcp.py script from the terminal, passing an issue ID (e.g., python run_mcp.py --issue PROJ - 123).
2. Extraction (Jira): The script uses the src/core/jira.py module to connect to the Jira API and obtain the details of PROJ - 123 (title, description, acceptance criteria).
3. Generation (Gemini): The script passes this information to the src/core/llm.py module, which constructs a prompt and sends it to the Gemini API in Vertex AI.
4. Response (Gemini): Gemini returns a structured response (e.g., a JSON with a list of TCs in Gherkin).
5. Creation (Jira/Xray): The script takes these TCs and, using src/core/jira.py again, creates a "Test" issue for each test case in Jira, automatically linking them to the US PROJ - 123.
6. End: The script prints the confirmation in the terminal. The QA Analyst can now see their TCs created in Jira.

🛠️ Tech Stack

• Backend: Python 3.10+
• Artificial Intelligence: Google Gemini via Google Cloud Vertex AI
• Integration: Jira REST API (using the requests library)
• CLI: Python's argparse
• Configuration: python - dotenv for secure credential management

🚀 Quick Start

Follow these steps to configure and run the project on your local machine.

Prerequisites

• Python 3.10 or higher.
• A Jira Cloud account with Xray installed.
• Permissions to create API Tokens in Atlassian.
• A Google Cloud project with the Vertex AI API enabled and authentication credentials (a service account JSON file).

Installation

1. Clone this repository:

git clone https://github.com/tu - usuario/mcp - xray - python.git
cd mcp - xray - python

2. Create a virtual environment:

python -m venv venv

3. Activate the virtual environment:
   • On macOS/Linux: source venv/bin/activate
   • On Windows: .\\venv\\Scripts\\activate
4. Install the dependencies:

pip install -r requirements.txt

Credential Configuration

This project uses a .env file to securely manage sensitive information.

1. Create a copy of the example file:

cp .env.example .env

2. Open the .env file with your text editor and fill in ALL the variables:

# JIRA Configuration
JIRA_URL="https://tu - instancia.atlassian.net"
JIRA_USER="tu - email - de - jira@dominio.com"
JIRA_API_TOKEN="TU_API_TOKEN_DE_JIRA_AQUI"
JIRA_PROJECT_KEY="PROJ" # Your Jira project key (e.g., 'TEST')

# Google Vertex AI (Gemini) Configuration
VERTEX_AI_PROJECT_ID="tu - id - de - proyecto - gcp"
VERTEX_AI_LOCATION="us - central1" # or the region you're using

# Path to the Google Cloud credentials JSON file
# Make sure this path is correct
GOOGLE_APPLICATION_CREDENTIALS="./ruta/a/tu/archivo - credenciales.json"

# Gemini Model Configuration
GEMINI_MODEL_NAME="gemini - 1.5 - pro" # or your preferred model

🏁 Usage

Once your virtual environment is activated (venv) and your .env file is configured, running the tool is as simple as running the run_mcp.py script with the Jira issue ID.

• Basic usage example:

python run_mcp.py --issue ALL - 8296

• Example deleting obsolete tests (instead of just tagging them):

python run_mcp.py --issue ALL - 8296 --delete - obsolete

🧪 Unit Tests

The project includes a set of unit tests to ensure the quality and stability of the code in the main modules.

1. Install development dependencies: Make sure you have pytest installed (included in requirements.txt):

   pip install -r requirements.txt
   

2. Run the tests: From the project's root folder, simply run:

   pytest
   

🤝 Contributions

Contributions are welcome! If you have ideas to improve the tool, optimize the Gemini prompts, or add new features, please:

1. Fork the project.
2. Create your feature branch (git checkout -b feature/MejoraIncreible).
3. Commit your changes (git commit -m 'Añade MejoraIncreible').
4. Push to the branch (git push origin feature/MejoraIncreible).
5. Open a Pull Request.

📄 License

This project is under the MIT License. See the LICENSE file for more details.