CREATE DATABASE bitbucket_db;
    CREATE DATABASE jira_db;

    CREATE USER bitbucket_user WITH PASSWORD 'StrongBitbucketPassword';
    CREATE USER jira_user WITH PASSWORD 'StrongJiraPassword';

    GRANT ALL PRIVILEGES ON DATABASE bitbucket_db TO bitbucket_user;
    GRANT ALL PRIVILEGES ON DATABASE jira_db TO jira_user;

    sudo apt update && sudo apt upgrade -y
    sudo apt install -y docker.io docker-compose
    sudo systemctl enable docker && sudo systemctl start docker
    # Install Git LFS
    sudo apt update
    sudo apt install git-lfs -y
    # Enable Git LFS
    git lfs install
    mkdir -p /opt/atlassian/bitbucket /opt/atlassian/jira
    chown -R 2001:2001 /opt/atlassian/bitbucket # For Bitbucket
    chown -R 2002:2002 /opt/atlassian/jira # For Jira

version: '3'
    services:
      bitbucket:
        image: atlassian/bitbucket:latest
        ports:
          - "7990:7990"
          - "7999:7999"
        environment:
          - 'JDBC_URL=jdbc:postgresql://my-postgres-db.postgres.database.azure.com:5432/bitbucket_db'
          - 'JDBC_USER=bitbucket_user'
          - 'JDBC_PASSWORD=StrongBitbucketPassword'
          - 'BITBUCKET_LFS_ENABLED=true' # Enable Git LFS
          volumes:
          - /opt/atlassian/bitbucket:/var/atlassian/application-data/bitbucket
          restart: unless-stopped
        networks:
          - atlassian
    networks:
      atlassian:

version: '3'
    services:
      jira:
        image: atlassian/jira-software:latest
        ports:
          - "8080:8080"
        environment:
          - 'JDBC_URL=jdbc:postgresql://my-postgres-db.postgres.database.azure.com:5432/jira_db'
          - 'JDBC_USER=jira_user'
          - 'JDBC_PASSWORD=StrongJiraPassword'
        volumes:
          - /opt/atlassian/jira:/var/atlassian/application-data/jira
        restart: unless-stopped
        networks:
          - atlassian
    networks:
      atlassian:

cd /opt/atlassian
    docker-compose up -d

# Initialize Git LFS
    git lfs install
    
    # Track specific file types for Unreal Engine 3 development
    git lfs track "*.ico" "*.upk" "*.umap" "*.psa" "*.psk" "*.abs" "*.fxa" "*.fbx" "*.png" "*.psd" "*.wav" "*.mp4" \
    "*.bik" "*.tga" "*.bmp" "*.dds" "*.jpg" "*.jpeg" "*.ogg" "*.mp3" "*.usx" "*.utx" "*.uax" "*.ukx" "*.unr" "*.uc" "*.u" \
    "*.swf" "*.bin" "*.pak" "*.iso" "*.zip" "*.rar" "*.dll" "*.lib" "*.pdb" "*.exe" "*.sln" "*.vcproj" "*.vcxproj" "*.ncb" \
    "*.sdf" "*.log" "*.t3d" "*.udk" "*.chtml"
    
    # Track additional 3D model formats
    git lfs track "*.max" "*.3ds" "*.mb" "*.ma" "*.blend" "*.ztl" "*.ztb" "*.tbx" "*.mtl" "*.obj" "*.stl" "*.bgeo" "*.abc" \
    "*.ply" "*.gltf" "*.glb" "*.igs" "*.step" "*.stp" "*.x3d" "*.bsp" "*.vox"
    
    # Track texture, material, and shader files
    git lfs track "*.tiff" "*.tif" "*.exr" "*.hdr" "*.pfm" "*.raw" "*.ies" "*.sbsar" "*.sbs" "*.sppr" "*.tx" "*.xcf" "*.mat"
    \
    "*.cg" "*.cgfx" "*.sma" "*.smi" "*.ptx"
    
    # Track animation, rigging, and physics files
    git lfs track "*.bvh" "*.c3d" "*.anim" "*.skel" "*.rig" "*.mc" "*.mcx" "*.phy"
    
    # Track Unreal Engine and game asset files
    git lfs track "*.udk" "*.ukx" "*.uax" "*.utx" "*.usx" "*.fxa" "*.fxp" "*.bik" "*.swf" "*.gtl" "*.gma" "*.pak"
    "*.pakchunk*" \
    "*.pak.info" "*.umx" "*.uplugin" "*.uproject" "*.uasset" "*.uexp" "*.ubulk"
    
    # Track audio and video files
    git lfs track "*.wav" "*.mp3" "*.ogg" "*.flac" "*.m4a" "*.aac" "*.ac3" "*.mov" "*.avi" "*.wmv" "*.flv" "*.mkv" "*.m4v"
    "*.mxf" \
    "*.r3d"
    
    # Track compression and archive formats
    git lfs track "*.7z" "*.tar" "*.gz" "*.lz4" "*.lzma" "*.xz" "*.cab" "*.msi"
    
    # Track Visual Studio and development files
    git lfs track "*.vcxproj.user" "*.vsconfig" "*.props" "*.targets" "*.filters" "*.hlsl" "*.glsl" "*.fx" "*.fxc" "*.bat"
    "*.sh" \
    "*.cmd" "*.patch" "*.diff" "*.cmake" "*.mak" "*.vssettings"
    
    # Verify tracked files
    cat .gitattributes
    
    # Commit the changes
    git add .gitattributes
    git commit -m "Enable Git LFS tracking"
    git push origin main
    
    

sudo apt update && sudo apt install -y nginx certbot python3-certbot-nginx

sudo nano /etc/nginx/sites-available/default

server {
      listen 80;
      server_name bitbucket.yourcompany.com;
        
    location / {
      proxy_pass http://127.0.0.1:7990;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $host;
      }
    }
        

sudo systemctl restart nginx

sudo certbot --nginx -d bitbucket.yourcompany.com

sudo certbot --nginx -d jira.yourcompany.com

sudo systemctl enable certbot.timer

🔧 Azure Bitbucket-MPC + Crawl4AI RAG Integration

📦 Architecture

+-----------------------------------------------------+
|                 Azure Infrastructure                |
|                                                     |
|  +--------------+   +------------------+            |
|  | Bitbucket VM |   | Jira VM          |            |
|  | Docker, Git  |   | Docker, Tickets  |            |
|  | Git LFS      |   | Agile Workflows  |            |
|  +--------------+   +------------------+            |
|       ↘                  ↙                         |
|   Azure PostgreSQL (pgvector enabled)              |
|       ↙                  ↘                         |
| +------------------------------------------------+ |
| | Bitbucket-MPC + RAG Layer                      | |
| | - Connects to Bitbucket/Jira APIs              | |
| | - Stores metadata, embeddings in PostgreSQL    | |
| | - Uses Crawl4AI RAG MCP Server (Docker)        | |
| | - Optional local LLM via Ollama                | |
| +------------------------------------------------+ |
|         ↘                          ↙              |
|  Dockerized MCP Server          Supabase Schema   |
+-----------------------------------------------------+
  

🧩 Crawl4AI RAG Integration

• Uses perform_rag_query() to answer semantic queries
• Stores indexed crawled + project data in Supabase-compatible PostgreSQL
• Embeds OpenAI or Ollama-based vector search

🛠 Terraform (Azure)

module "mcp_rag" {
  source = "./modules/container-app"
  name   = "mcp-rag"
  image  = "youracr.azurecr.io/mcp-rag:latest"

  env = {
    OPENAI_API_KEY         = var.openai_key
    SUPABASE_URL           = var.supabase_url
    SUPABASE_SERVICE_KEY   = var.supabase_key
    HOST                   = "0.0.0.0"
    PORT                   = "8051"
    TRANSPORT              = "sse"
  }

  ports = [8051]
}
  

🐳 Docker Build & Push to Azure

# Clone the repo
git clone https://github.com/coleam00/mcp-crawl4ai-rag.git
cd mcp-crawl4ai-rag

# Build Docker image
docker build -t youracr.azurecr.io/mcp-rag:latest .

# Login & push to ACR
az acr login --name youracr
docker push youracr.azurecr.io/mcp-rag:latest
  

📂 PostgreSQL Schema (Supabase-Compatible)

# Connect to Azure PostgreSQL and run:
psql "host=your-db.postgres.database.azure.com user=admin dbname=supabase" -f crawled_pages.sql
  

📋 .env Configuration

HOST=0.0.0.0
PORT=8051
TRANSPORT=sse
OPENAI_API_KEY=your_openai_key
SUPABASE_URL=your_supabase_project_url
SUPABASE_SERVICE_KEY=your_supabase_service_key
  

💡 Sample Query

import requests

res = requests.post("http://mcp-rag-server:8051/perform_rag_query", json={
  "query": "Which PR added PlayExplosionEffect()?",
  "filters": { "source": "bitbucket" }
})

print(res.json())
  

🚀 AI + RAG Use Cases

• Find where a function or asset was introduced
• Trace ticket → PR → file relationships
• Search across UnrealScript, C++, LFS using natural language

Cost Summary for Bitbucket, Jira, PostgreSQL Setup with RAG Integration

🔧 Crawl4AI RAG + UE3 Game Development

For a team working on an Unreal Engine 3 (UE3) game with Windows, Visual Studio 2008, and the UE3 source code, integrating the Crawl4AI RAG system you’ve outlined would significantly enhance their ability to efficiently search, trace, and extend the codebase. The core benefit would be facilitating a more intuitive way to access and search the source code, pull relevant data from commits and pull requests, trace ticket and code relationships, and even collaborate on improving the game’s knowledge base.

1. Integration of Crawl4AI RAG with UE3 Codebase

System Setup:

• Bitbucket: The UE3 source code (and any related documentation) is stored in Bitbucket repositories. Bitbucket is integrated with Git LFS for large binary assets (like textures, meshes, etc.), which is typical in Unreal Engine projects.
• Jira: The team uses Jira to manage tasks, sprints, bugs, and new feature requests. This is useful for keeping track of all the work done across the project.
• Crawl4AI RAG: This system will be connected to both Bitbucket (for commits, pull requests, codebase changes) and Jira (for ticket management) to index relevant metadata. Using semantic search powered by RAG, it can search the codebase, tickets, and documentation to answer complex queries.

2. Workflow with Crawl4AI RAG in the Context of UE3 Development

A) Knowledge Base Creation & Expansion:

• Crawling Data: The Crawl4AI RAG system will periodically crawl the Bitbucket repositories and the Jira tickets. This can include:
  • Commit Messages: Extracting information from commit messages, such as what features or fixes were added in a particular commit.
  • Pull Requests: Extracting metadata and code diffs from pull requests. The system would capture which features were added, what code changed, and which files were affected.
  • Jira Tickets: Crawling Jira tickets for related information, such as ticket descriptions, issue types (bug, enhancement, feature), and comments that may contain useful context about specific issues.
  • UE3 Source Code: The system will analyze UnrealScript and C++ code in the UE3 source code to build semantic embeddings of functions, assets, and features. This will allow users to query specific code segments, file changes, or even project history (e.g., "Where is PlayExplosionEffect() defined and used?").

B) Searching for Information:

• Natural Language Queries: Team members can ask natural language questions, such as:
  • "What was the last change to the AIBehavior class?"
  • "Which pull request added the feature for character animations?"
  • "What Jira ticket corresponds to the crash in RenderEngine.cpp?"
• The system will return relevant results based on semantic similarity from the stored data, which could include code snippets, commit history, Jira tickets, and related documentation.

C) Trace Code and Tickets Across Systems:

• Trace Commit → Pull Request → Ticket: A developer working on a feature might have to trace through code changes that were linked to a Jira ticket. Instead of manually searching through Git logs or Jira, they can query the system directly with questions like:
  • "Which pull request corresponds to the fix for the crash on startup?"
  • "What changes were made in relation to the bug #123?"
• The system will find connections between the commit, the pull request, and the Jira ticket, providing a holistic view of what was done and why.

D) Handling UnrealScript & C++ Codebase:

• Search UnrealScript Functions/Assets: UnrealScript has a somewhat different structure compared to traditional C++ code. The system should be able to:
  • Recognize function names like PlayExplosionEffect().
  • Identify the files where UnrealScript functions are declared and used.
  • Link UnrealScript code to C++ classes if the system uses hybrid UnrealScript/C++ code.
• Semantic Code Search: As the game is being developed using Visual Studio 2008, the system would parse the C++ and UnrealScript code to create vector embeddings of the code. This would allow semantic searches of the codebase, answering questions like:
  • "Where is PlayExplosionEffect() defined?"
  • "Where is the AIBehavior class referenced in the project?"

E) Team Collaboration and Offline Syncing:

• Extending the Knowledge Base: As developers contribute new links, code, or insights to the project, they can upload that data to the system, which gets stored in the Crawl4AI database. For example:
  • Developers could find a new piece of code or a solution to an issue while working offline. They can add their changes to their local system’s version of the knowledge base.
  • When they’re online again, the local version can be synchronized with the central system (hosted in Azure or Supabase), ensuring that all team members get the latest updates.
• Versioning: By storing crawled data in GitLab (team-knowledge-db), you can version control the knowledge base itself. When one developer adds a new link, file, or piece of metadata to the knowledge base, the data is committed and pushed to the central repository. This ensures consistency across multiple contributors.

F) Example Scenario in UE3 Development:

• Developer 1: is working on a bug in the AIBehavior class and wants to know where the class is used throughout the codebase. They ask the system:
  • "Where is AIBehavior used in the codebase?"
• The system provides links to the relevant source files, PRs, and tickets related to the class.
• Developer 2: is tasked with enhancing the PlayExplosionEffect() function. They ask:
  • "When was PlayExplosionEffect() introduced?"
• The system shows the relevant commit history and pull requests.
• Developer 3: is working on a new feature and needs context about a specific bug report related to the feature. They query the system:
  • "Which Jira ticket describes the bug for character animation?"
• The system returns a list of related Jira tickets and their linked commits.

3. Summary of the Workflow

• Data Crawling: Crawl data from Bitbucket, Jira, and the Unreal Engine codebase.
• Semantic Search: Team members use natural language queries to find connections between code, tickets, commits, and assets.
• Team Collaboration: Team members enrich the knowledge base by adding links, code, and tickets.
• Version Control: Use GitLab or another versioning system to ensure consistency and track changes to the knowledge base.

Final Thoughts:

By integrating the Crawl4AI RAG system with the UE3 source code, Bitbucket, and Jira, you will streamline the development workflow, making it easier for your team to track changes, search the codebase, and collaborate on fixing bugs and adding new features. Developers will spend less time searching through the code and tickets manually, and more time actually coding and improving the game. The added benefit of offline syncing and versioning will allow your team to work seamlessly even when working in different locations or environments.

Would you like help with specific technical details or steps to implement this system?