Upload 11 files

Dockerfile

@@ -0,0 +1,41 @@
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git \
+    redis-server \
+    curl \
+    procps \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+WORKDIR /app
+
+# Copy project files
+COPY pyproject.toml uv.lock /app/
+RUN uv sync --frozen --no-install-project
+
+COPY . /app
+RUN uv sync --frozen
+
+# Clone MCP server
+RUN git clone https://github.com/alexcpn/codereview_mcp_server.git
+
+# Make startup script executable
+RUN chmod +x start_hf.sh
+
+# Create a user to run the app (optional but good practice, though HF often runs as 1000)
+# For simplicity in this setup, we'll run as root or default user, 
+# but we need to make sure we can write to directories if needed.
+# HF Spaces usually run as user 1000.
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Expose the port (HF Spaces expects 7860)
+EXPOSE 7860
+
+CMD ["./start_hf.sh"]

Dockerfile.local

@@ -0,0 +1,21 @@
+FROM python:3.10-slim-trixie
+
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+WORKDIR /app
+
+# Install dependencies first (cached unless lockfile changes)
+COPY pyproject.toml uv.lock /app/
+RUN uv sync --frozen --no-install-project
+
+# Then copy the rest of the code
+COPY . /app
+RUN uv sync --frozen
+
+# Run the server
+# Run the server
+CMD ["uv", "run", "python", "agent_interface.py"]
+
+# Build the docker
+# docker build -t codereview-agent .
+# run as
+# docker run -it --rm -p 7860:7860 codereview-agent

README.md

@@ -1,11 +1,149 @@
 ---
-title: Code Review Agent
-emoji: 🌍
-colorFrom: pink
-colorTo: gray
+
+title: Code Review Agentic AI based on MCP
+emoji: 🛰️
+colorFrom: indigo
+colorTo: blue
 sdk: docker
+app_file: Dockerfile
 pinned: false
-short_description: An Angentic AI example with code review
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Agentic AI Code Review in Pure Python - No Agentic Framework
+
+Agentic code review pipeline that plans, calls tools, and produces structured findings without any heavyweight framework. Implemented in plain Python using [uv](https://github.com/astral-sh/uv), [FastAPI](https://fastapi.tiangolo.com/), and a small footprint wrapper library [nmagents](https://github.com/alexcpn/noagent-ai). Deep code context comes from a Tree-Sitter-backed Model Context Protocol (MCP) server.
+
+## What this repo demonstrates
+- End-to-end AI review loop in a few hundred lines of Python (`code_review_agent.py`)
+- Tool-augmented LLM via Tree-Sitter AST introspection from an MCP server
+- Deterministic step planning/execution with JSON repair and YAML logs
+- Works with OpenAI or any OpenAI-compatible endpoint (ollam,vllm)
+- Ships as a FastAPI service, CLI helper, and Docker image
+
+## How it works
+- Fetch the PR diff, ask the LLM for a per-file review plan, then execute each step.
+- MCP server ([codereview_mcp_server](https://github.com/alexcpn/codereview_mcp_server)) exposes AST tools (definitions, call-sites, docstrings) using [Tree-Sitter](https://tree-sitter.github.io/tree-sitter/).
+- Minimal orchestration comes from [nmagents](https://github.com/alexcpn/noagent-ai) Command pattern: plan → optional tool calls → critique/patch suggestions → YAML logs.
+
+Models are effective with very detailed prompts instead of one-liners. Illustration prompt is [prompts/code_review_prompts.txt](prompts/code_review_prompts.txt)  with context populated at place holders.
+
+Results are good if a task can be broken into steps and each step executed in place. This keeps the context tight.
+
+Models which gives good result are GPT 4.1 Nano, GPT 5 Nano. 
+
+Also this will run with any OpenAI API comptatible model; Like ollam (with Microsoft phi3.5 model) and vllm (with Google gemma model) wtih a laptop GPU.
+
+Note that these small models are really not that good with complex tasks like this.
+
+### Core flow (excerpt from `review_orchestrator.py`)
+
+```python
+file_diffs = git_utils.get_pr_diff_url(repo_url, pr_number)
+response = call_llm_command.execute(context)                # plan steps
+response_data, _ = parse_json_response_with_repair(...)     # repair/parse plan
+
+tools = step.get("tools", [])
+if tools:
+    tool_outputs = await execute_step_tools(step, ast_tool_call_command)
+
+step_context = load_prompt(diff_or_code_block=diff, tool_outputs=step.get("tool_results", ""))
+step_response = call_llm_command.execute(step_context)      # execute each step
+```
+
+## Prerequisites
+- Python 3.10+
+- [uv](https://github.com/astral-sh/uv) installed
+- `.env` with `OPENAI_API_KEY=...`
+- Running MCP server with AST tools (e.g., [codereview_mcp_server](https://github.com/alexcpn/codereview_mcp_server)) reachable at `CODE_AST_MCP_SERVER_URL`
+
+# Setup
+
+## Start the Code Review MCP server
+```bash
+git clone https://github.com/alexcpn/codereview_mcp_server.git
+cd codereview_mcp_server
+uv run python http_server.py  # serves MCP at http://127.0.0.1:7860/mcp/
+```
+
+# Running Locally with Ray (Pure Ray)
+
+This is the simplest way to run the agent without Kubernetes complexity.
+
+## Start Ray
+Start a local Ray cluster instance:
+```bash
+uv run ray start --head
+# if there is problem with start up, kill old process
+ray stop --force
+```
+*Note: This starts Ray on your local machine. You can view the dashboard at http://127.0.0.1:8265*
+
+
+## Run Redis with persistent storage:
+
+```
+docker run -d \
+  -p 6380:6379 \
+  --name redis-review \
+  -v $(pwd)/redis-data:/data \
+  redis \
+  redis-server --appendonly yes
+```
+
+To delete older jobs
+```
+redis-cli --scan --pattern "review:*" | xargs redis-cli del
+```
+
+
+## Run the Agentic AI Webserver
+
+Note - see the .env (copy) file and create a .env file with the same variables but correct values
+
+```
+OPENAI_API_KEY=xxx
+REDIS_PORT=6380
+AST_MCP_SERVER_URL=http://127.0.0.1:7860/mcp/
+RAY_ADDRESS="auto"
+```
+
+```
+uv run web_server.py 
+```
+This will start the web server on http://0.0.0.0:8000/
+
+You will get a UI to trigger the review and see triggered reviews and steps
+
+![webpage](https://i.postimg.cc/vB2v53pk/image.png)
+
+## Deploying to Hugging Face Spaces
+
+This repository includes a configuration to deploy directly to Hugging Face Spaces (Docker SDK).
+
+1.  **Create a New Space**:
+    - Go to [Hugging Face Spaces](https://huggingface.co/spaces).
+    - Create a new Space.
+    - Select **Docker** as the SDK.
+
+2.  **Upload Files**:
+    - Upload the contents of this repository to your Space.
+    - **Important**: You must tell Hugging Face to use `Dockerfile.hf` instead of the default `Dockerfile`.
+    - You can do this by renaming `Dockerfile.hf` to `Dockerfile` in the Space, or by configuring the Space settings if supported.
+    - *Recommendation*: Rename `Dockerfile` to `Dockerfile.local` and `Dockerfile.hf` to `Dockerfile` before pushing to the Space.
+
+3.  **Set Secrets**:
+    - In your Space settings, go to **Settings > Variables and secrets**.
+    - Add a new secret: `OPENAI_API_KEY` with your API key.
+
+4.  **Run**:
+    - The Space will build and start.
+    - Once running, you will see the web interface.
+
+---
+
+## References
+- [Model Context Protocol](https://github.com/modelcontextprotocol/specification)
+- [Tree-Sitter](https://tree-sitter.github.io/tree-sitter/)
+- [codereview_mcp_server](https://github.com/alexcpn/codereview_mcp_server)
+- [nmagents (noagent-ai)](https://github.com/alexcpn/noagent-ai)
+- [uv package manager](https://github.com/astral-sh/uv)

agent_interface.py

@@ -0,0 +1,48 @@
+import grpc
+from concurrent import futures
+import logging as log
+import os
+import asyncio
+import protos.agent_pb2 as agent_pb2
+import protos.agent_pb2_grpc as agent_pb2_grpc
+from review_orchestrator import CodeReviewOrchestrator
+from load_dotenv import load_dotenv
+load_dotenv()
+
+# Configure logging
+log.basicConfig(level=log.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+class CodeReviewAgentServicer(agent_pb2_grpc.CodeReviewAgentServicer):
+    def __init__(self):
+        self.orchestrator = CodeReviewOrchestrator()
+
+    def ReviewPR(self, request, context):
+        repo_url = request.repo_url
+    async def ReviewPR(self, request, context):
+        log.info(f"Received review request for PR #{request.pr_number}")
+        try:
+            async for result in self.orchestrator.review_pr_stream(request.repo_url, request.pr_number):
+                yield agent_pb2.ReviewResponse(
+                    status="Success",
+                    review_comment=result["comment"],
+                    file_path=result["file_path"]
+                )
+        except Exception as e:
+            log.error(f"Error during review: {e}")
+            yield agent_pb2.ReviewResponse(
+                status="Error",
+                review_comment=str(e),
+                file_path=""
+            )
+
+async def serve():
+    server = grpc.aio.server()
+    agent_pb2_grpc.add_CodeReviewAgentServicer_to_server(CodeReviewAgentServicer(), server)
+    server.add_insecure_port('[::]:50051')
+    log.info("Starting Async gRPC server on port 50051...")
+    await server.start()
+    await server.wait_for_termination()
+
+if __name__ == '__main__':
+    import asyncio
+    asyncio.run(serve())

git_utils.py

@@ -0,0 +1,31 @@
+import requests
+import re
+from collections import defaultdict
+import logging as log
+
+
+def get_pr_diff_url(repo_url, pr_number):
+    """ 
+    Get the diff URL for a specific pull request number.
+    Args:
+        repo_url (str): The URL of the GitHub repository.
+        pr_number (int): The pull request number.
+    """
+    pr_diff_url = f"https://patch-diff.githubusercontent.com/raw/{repo_url.split('/')[-2]}/{repo_url.split('/')[-1]}/pull/{pr_number}.diff"
+    response = requests.get(pr_diff_url,verify=False)
+
+    if response.status_code != 200:
+        log.error(f"Failed to fetch diff: {response.status_code}")
+        raise ValueError(f"Failed to fetch diff: {response.status_code}")
+
+    diff_text = response.text
+    file_diffs = defaultdict(str)
+    file_diff_pattern = re.compile(r'^diff --git a/(.*?) b/\1$', re.MULTILINE)
+    split_points = list(file_diff_pattern.finditer(diff_text))
+    for i, match in enumerate(split_points):
+        file_path = match.group(1)
+        start = match.start()
+        end = split_points[i + 1].start() if i + 1 < len(split_points) else len(diff_text)
+        file_diffs[file_path] = diff_text[start:end]
+    return file_diffs
+

pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "llm-code-review-agent"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.115.12",
+    "fastmcp>=2.3.4",
+    "gitpython>=3.1.44",
+    "mcp[cli]>=1.9.0",
+    "openai>=1.79.0",
+    "openai-agents>=0.0.17",
+    "pyyaml>=6.0.2",
+    "requests>=2.32.3",
+    "tiktoken>=0.9.0",
+    "uvicorn>=0.34.2",
+    "ray[default]==2.41.0",
+    "grpcio>=1.60.0",
+    "grpcio-tools>=1.60.0",
+    "nmagents>=0.1.0",
+    "load-dotenv>=0.1.0",
+    "redis>=5.0.0",
+    "jinja2>=3.1.0",
+]

review_orchestrator.py

@@ -0,0 +1,348 @@
+import ray
+import os
+import logging as log
+import yaml
+from datetime import datetime
+from typing import Any, List, Dict
+import git_utils
+from fastmcp import Client
+from openai import OpenAI
+from dotenv import load_dotenv
+from nmagents.command import CallLLM, ToolCall, ToolList
+from nmagents.utils import parse_json_response_with_repair, execute_step_tools
+from pathlib import Path
+import redis
+import json
+
+# Configure logging
+log.basicConfig(level=log.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+
+# Load environment variables
+load_dotenv()
+
+# Constants
+MAX_CONTEXT_LENGTH = 16385
+COST_PER_TOKEN_INPUT = 0.10 / 10e6
+COST_PER_TOKEN_OUTPUT = 0.40 / 10e6
+MODEL_NAME = "gpt-4.1-nano"
+FALLBACK_MODEL_NAME = os.getenv("JSON_REPAIR_MODEL", "gpt-4.1-nano")
+FALLBACK_MAX_BUDGET = float(os.getenv("JSON_REPAIR_MAX_BUDGET", "0.2"))
+AST_MCP_SERVER_URL = os.getenv("CODE_AST_MCP_SERVER_URL", "http://127.0.0.1:7860/mcp/")
+
+if AST_MCP_SERVER_URL and not AST_MCP_SERVER_URL.endswith("/"):
+    AST_MCP_SERVER_URL = AST_MCP_SERVER_URL + "/"
+
+TEMPLATE_PATH = Path(__file__).parent / "prompts/code_review_prompts.txt"
+
+def load_prompt(**placeholders) -> str:
+    template = TEMPLATE_PATH.read_text(encoding="utf-8")
+    default_values = {
+        "arch_notes_or_empty": "",
+        "guidelines_list_or_link": "",
+        "threat_model_or_empty": "",
+        "perf_slos_or_empty": "",
+        "tool_outputs": "",
+        "diff_or_code_block": "",
+    }
+    merged = {**default_values, **placeholders}
+    for key, value in merged.items():
+        value_str = str(value)
+        template = template.replace(f"{{{{{key}}}}}", value_str)
+        template = template.replace(f"{{{key}}}", value_str)
+    return template
+
+@ray.remote
+def process_file_review(file_path: str, diff: str, repo_url: str, pr_number: int, tool_schemas_content: str, step_schema_content: str, time_hash: str, redis_host: str, redis_port: int, api_key: str | None = None, mcp_server_url: str | None = None):
+    import asyncio
+    return asyncio.run(_process_file_review_async(file_path, diff, repo_url, pr_number, tool_schemas_content, step_schema_content, time_hash, redis_host, redis_port, api_key, mcp_server_url))
+
+async def _process_file_review_async(file_path: str, diff: str, repo_url: str, pr_number: int, tool_schemas_content: str, step_schema_content: str, time_hash: str, redis_host: str, redis_port: int, api_key: str | None = None, mcp_server_url: str | None = None):
+    log.info(f"Starting review for {file_path}")
+    
+    # Initialize Redis client
+    # redis_host and redis_port are passed from the orchestrator
+    redis_client = redis.Redis(host=redis_host, port=redis_port, db=0)
+    repo_name = repo_url.rstrip('/').split('/')[-1]
+    stream_key = f"review:stream:{repo_name}:{pr_number}:{time_hash}"
+    runs_key = f"review:runs:{repo_name}:{pr_number}"
+    
+    # Add this run to the history
+    try:
+        redis_client.sadd(runs_key, time_hash)
+    except Exception as e:
+        log.error(f"Failed to add run to history: {e}")
+    
+    # Re-initialize clients inside the remote task
+    if not api_key:
+        api_key = os.getenv("OPENAI_API_KEY")
+    openai_client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
+    
+    call_llm_command = CallLLM(openai_client, "Call the LLM", MODEL_NAME, COST_PER_TOKEN_INPUT, COST_PER_TOKEN_OUTPUT, 0.5)
+    repair_llm_command = CallLLM(openai_client, "Repair YAML", FALLBACK_MODEL_NAME, COST_PER_TOKEN_INPUT, COST_PER_TOKEN_OUTPUT, FALLBACK_MAX_BUDGET)
+    
+    step_execution_results = []
+    
+    # Use passed URL or fallback to env var
+    mcp_url = mcp_server_url or AST_MCP_SERVER_URL
+    if not mcp_url.endswith("/"):
+        mcp_url = mcp_url + "/"
+
+    async with Client(mcp_url) as ast_tool_client:
+        ast_tool_call_command = ToolCall(ast_tool_client, "Call tool")
+        
+        main_context = f""" Your task today is Code Reivew. You are given the following '{pr_number}' to review from the repo '{repo_url}' 
+        You have to first come up with a plan to review the code changes in the PR as a series of steps.
+        Write the plan as per the following step schema: {step_schema_content}
+        Make sure to follow the step schema format exactly  and output only JSON """
+        
+        context = main_context + f" Here is the file diff for {file_path}:\n{diff} for review\n" + \
+            f"You have access to the following MCP tools to help you with your code review: {tool_schemas_content}"
+            
+        response = call_llm_command.execute(context)
+        log.info(f"Plan generated for {file_path}")
+        
+        response_data, _ = parse_json_response_with_repair(
+            response_text=response or "",
+            schema_hint=step_schema_content,
+            repair_command=repair_llm_command,
+            context_label="plan",
+        )
+        
+        if not response_data:
+            log.error(f"Failed to parse plan for {file_path}")
+            return {
+                "file_path": file_path,
+                "results": [{"step_name": "plan", "error": "Failed to parse plan"}]
+            }
+
+        # Save plan log
+        safe_filename = file_path.replace("/", "_").replace("\\", "_")
+        repo_name = repo_url.rstrip('/').split('/')[-1]
+        job_dir = f"{repo_name}_PR{pr_number}_{time_hash}"
+        logs_dir = Path("logs") / job_dir
+        logs_dir.mkdir(parents=True, exist_ok=True)
+        
+        plan_log_path = logs_dir / f"plan_{safe_filename}.yaml"
+        with open(plan_log_path, "w", encoding="utf-8") as f:
+            yaml.dump(response_data, f)
+
+        # Publish plan to Redis
+        try:
+            redis_client.xadd(stream_key, {
+                "type": "plan",
+                "file_path": file_path,
+                "content": json.dumps(response_data)
+            })
+        except Exception as e:
+            log.error(f"Failed to write plan to Redis: {e}")
+        
+        steps = response_data.get("steps", [])
+        
+        for index, step in enumerate(steps, start=1):
+            name = step.get("name", "<unnamed>")
+            step_description = step.get("description", "")
+            
+            tools = step.get("tools", [])
+            if tools:
+                log.info(f"Executing tools for step {name}: {tools}")
+                tool_outputs = await execute_step_tools(step, ast_tool_call_command)
+                for output in tool_outputs:
+                    tool_result_context = load_prompt(repo_name=repo_url, brief_change_summary=step_description,
+                                                diff_or_code_block=diff, tool_outputs=output)
+                    step["tool_results"] = tool_result_context
+            
+            try:
+                step_context = load_prompt(repo_name=repo_url, brief_change_summary=step_description,
+                                           diff_or_code_block=diff, tool_outputs=step.get("tool_results", ""))
+                
+                step_response = call_llm_command.execute(step_context)
+                
+                step_data, _ = parse_json_response_with_repair(
+                    response_text=step_response or "",
+                    schema_hint="",
+                    repair_command=repair_llm_command,
+                    context_label=f"step {name}",
+                )
+                
+                if not step_data:
+                    log.error(f"Failed to parse result for step {name}")
+                    step_execution_results.append({
+                        "step_name": name,
+                        "error": "Failed to parse step result"
+                    })
+                    continue
+
+                # Save step log
+                step_log_path = logs_dir / f"step_{name}_{safe_filename}.yaml"
+                with open(step_log_path, "w", encoding="utf-8") as f:
+                    yaml.dump(step_data, f)
+                
+                step_execution_results.append({
+                    "step_name": name,
+                    "result": step_data
+                })
+
+                # Publish step result to Redis
+                try:
+                    redis_client.xadd(stream_key, {
+                        "type": "step",
+                        "file_path": file_path,
+                        "step_name": name,
+                        "content": json.dumps(step_data)
+                    })
+                except Exception as e:
+                    log.error(f"Failed to write step to Redis: {e}")
+                
+            except Exception as e:
+                log.error(f"Failed to execute step {name} for {file_path}: {e}")
+                step_execution_results.append({
+                    "step_name": name,
+                    "error": str(e)
+                })
+                break
+                
+    return {
+        "file_path": file_path,
+        "results": step_execution_results
+    }
+
+class CodeReviewOrchestrator:
+    def __init__(self):
+        # Initialize Ray
+        # Check if running in a cluster or local
+        ray_address = os.getenv("RAY_ADDRESS")
+        if ray_address:
+            ray.init(address=ray_address, ignore_reinit_error=True)
+        else:
+            ray.init(ignore_reinit_error=True)
+        
+    async def review_pr_stream(self, repo_url: str, pr_number: int, time_hash: str = None, api_key: str | None = None, mcp_server_url: str | None = None):
+        log.info(f"Orchestrating review for {repo_url} PR #{pr_number}")
+        
+        # Get diffs
+        try:
+            file_diffs = git_utils.get_pr_diff_url(repo_url, pr_number)
+        except Exception as e:
+            log.error(f"Failed to get diffs: {e}")
+            yield {
+                "type": "error",
+                "file_path": "system",
+                "content": json.dumps({"error": f"Failed to get diffs: {str(e)}"})
+            }
+            return
+        
+        # Get tool schemas (need to do this once)
+        # Use passed URL or fallback to env var
+        mcp_url = mcp_server_url or AST_MCP_SERVER_URL
+        if not mcp_url.endswith("/"):
+            mcp_url = mcp_url + "/"
+            
+        async with Client(mcp_url) as ast_tool_client:
+            ast_tool_list_command = ToolList(ast_tool_client, "List tools")
+            tool_schemas_content = await ast_tool_list_command.execute(None)
+            
+        sample_step_schema_file = "schemas/steps_schema.json"
+        with open(sample_step_schema_file, "r", encoding="utf-8") as f:
+            step_schema_content = f.read()
+            
+        if not time_hash:
+            time_hash = datetime.now().strftime("%Y%m%d%H%M%S")
+        
+        # Redis config to pass to workers
+        redis_host = os.getenv("REDIS_HOST", "localhost")
+        redis_port = int(os.getenv("REDIS_PORT", 6380))
+
+        # Launch Ray tasks
+        pending_futures = []
+        for file_path, diff in file_diffs.items():
+            pending_futures.append(process_file_review.remote(
+                file_path, diff, repo_url, pr_number, tool_schemas_content, step_schema_content, time_hash, redis_host, redis_port, api_key, mcp_url
+            ))
+            
+        # Collect all reviews for final summary
+        all_reviews_context = ""
+        
+        # Process results as they complete
+        while pending_futures:
+            # Run ray.wait in a separate thread to avoid blocking the asyncio event loop
+            import asyncio
+            done_futures, pending_futures = await asyncio.to_thread(ray.wait, pending_futures)
+            for future in done_futures:
+                try:
+                    result = await future
+                    
+                    # Format the result for this file
+                    file_summary = f"File: {result['file_path']}\n"
+                    for step in result['results']:
+                        if 'error' in step:
+                            file_summary += f"- {step['step_name']}: [Error] {step['error']}\n"
+                        else:
+                            file_summary += f"- {step['step_name']}: {step['result']}\n"
+                    
+                    all_reviews_context += file_summary + "\n" + "-"*40 + "\n"
+                    
+                    yield {
+                        "file_path": result['file_path'],
+                        "comment": file_summary
+                    }
+                except Exception as e:
+                    log.error(f"Error processing result from ray: {e}")
+                    yield {
+                        "file_path": "system",
+                        "comment": f"Error: {str(e)}"
+                    }
+        
+        # Generate Final Consolidated Summary
+        log.info("Generating consolidated PR summary...")
+        try:
+            if not api_key:
+                api_key = os.getenv("OPENAI_API_KEY")
+            openai_client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
+            summary_llm_command = CallLLM(openai_client, "Summarize PR", MODEL_NAME, COST_PER_TOKEN_INPUT, COST_PER_TOKEN_OUTPUT, 0.5)
+            
+            summary_prompt = f"""
+            You are a Principal Software Engineer. 
+            Review the following code review results for PR #{pr_number} in {repo_url}.
+            
+            Aggregated Reviews:
+            {all_reviews_context}
+            
+            Please provide a concise Executive Summary of the PR.
+            1. Highlight the most critical issues found across all files.
+            2. Identify any recurring patterns or code quality concerns.
+            3. Provide a final recommendation (Merge, Request Changes, etc.).
+            """
+            
+            final_summary = summary_llm_command.execute(summary_prompt)
+            
+            # Publish summary to Redis
+            try:
+                redis_client = redis.Redis(host=redis_host, port=redis_port, db=0)
+                stream_key = f"review:stream:{repo_url.rstrip('/').split('/')[-1]}:{pr_number}:{time_hash}"
+                redis_client.xadd(stream_key, {
+                    "type": "summary",
+                    "file_path": "PR_SUMMARY",
+                    "content": final_summary,
+                    "repo_url": repo_url,
+                    "pr_number": str(pr_number)
+                })
+                redis_client.close()
+            except Exception as e:
+                log.error(f"Failed to write summary to Redis: {e}")
+
+            yield {
+                "file_path": "PR_SUMMARY",
+                "comment": f"# Consolidated PR Summary\n\n{final_summary}"
+            }
+            
+            # Save summary log
+            logs_dir = Path("logs") / f"{repo_url.rstrip('/').split('/')[-1]}_PR{pr_number}_{time_hash}"
+            with open(logs_dir / "pr_summary.md", "w", encoding="utf-8") as f:
+                f.write(final_summary)
+                
+        except Exception as e:
+            log.error(f"Failed to generate final summary: {e}")
+            yield {
+                "file_path": "PR_SUMMARY",
+                "comment": f"Failed to generate summary: {e}"
+            }

start_hf.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+# Start Redis
+echo "Starting Redis..."
+redis-server --port 6380 &
+
+# Start Ray
+echo "Starting Ray..."
+# We use --head to start a single node cluster
+# We need to make sure it doesn't try to use too much memory if limited
+uv run ray start --head --disable-usage-stats --port=6379 --dashboard-host=0.0.0.0
+
+# Start MCP Server
+echo "Starting MCP Server..."
+cd codereview_mcp_server
+uv run http_server.py &
+MCP_PID=$!
+cd ..
+
+# Wait for MCP server to be ready (simple sleep for now, or check port)
+sleep 5
+
+# Set environment variables
+export REDIS_PORT=6380
+export AST_MCP_SERVER_URL=http://127.0.0.1:7860/mcp/
+export RAY_ADDRESS="auto"
+
+# Start Web Server
+echo "Starting Web Server..."
+# HF Spaces expects the app to listen on port 7860
+uv run uvicorn web_server:app --host 0.0.0.0 --port 7860

test_client.py

@@ -0,0 +1,25 @@
+import grpc
+import protos.agent_pb2 as agent_pb2
+import protos.agent_pb2_grpc as agent_pb2_grpc
+import logging as log
+
+log.basicConfig(level=log.INFO)
+
+def run():
+    with grpc.insecure_channel('localhost:50051') as channel:
+        stub = agent_pb2_grpc.CodeReviewAgentStub(channel)
+        log.info("Sending ReviewPR request...")
+        response_stream = stub.ReviewPR(agent_pb2.ReviewRequest(
+            repo_url="https://github.com/huggingface/accelerate",
+            pr_number=3321
+        ))
+        
+        log.info("Waiting for stream...")
+        for response in response_stream:
+            log.info(f"--- Received Review for {response.file_path} ---")
+            log.info(f"Status: {response.status}")
+            log.info(response.review_comment)
+            log.info("-" * 50)
+
+if __name__ == '__main__':
+    run()

web_server.py

@@ -0,0 +1,162 @@
+import os
+import json
+import asyncio
+import redis.asyncio as redis
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from review_orchestrator import CodeReviewOrchestrator
+from pydantic import BaseModel
+from load_dotenv import load_dotenv
+load_dotenv()
+app = FastAPI()
+templates = Jinja2Templates(directory="templates")
+
+# Initialize Orchestrator
+orchestrator = CodeReviewOrchestrator()
+
+class ReviewRequest(BaseModel):
+    repo_url: str
+    pr_number: int
+    openai_api_key: str | None = None
+    mcp_server_url: str | None = None
+
+class MCPRequest(BaseModel):
+    mcp_server_url: str
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/list-tools")
+async def list_tools(request: MCPRequest):
+    from fastmcp import Client
+    from nmagents.command import ToolList
+    
+    try:
+        # Ensure URL ends with /
+        url = request.mcp_server_url
+        if not url.endswith("/"):
+            url = url + "/"
+            
+        async with Client(url) as client:
+            # We can't easily use ToolList command here as it returns a formatted string
+            # We'll use the client directly to list tools if possible, or parse the output
+            # fastmcp client doesn't expose list_tools directly in a simple way without calling the server
+            # But nmagents ToolList does exactly that.
+            
+            tool_list_command = ToolList(client, "List tools")
+            tools_description = await tool_list_command.execute(None)
+            return {"status": "success", "tools": tools_description}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.post("/review")
+async def trigger_review(request: ReviewRequest, background_tasks: BackgroundTasks):
+    # Trigger the review in the background
+    # We need to wrap the async generator to consume it, otherwise it won't run
+    # We need to get the time_hash to return it, but the orchestrator generates it.
+    # For now, we will generate it here and pass it, or just return a "latest" indicator.
+    # Better: Orchestrator's review_pr_stream generates it. We can't easily get it back from a background task.
+    # Solution: We will generate time_hash here and pass it to orchestrator (need to update orchestrator signature).
+    
+    from datetime import datetime
+    time_hash = datetime.now().strftime("%Y%m%d%H%M%S")
+    
+    # Add run to history immediately
+    redis_host = os.getenv("REDIS_HOST", "localhost")
+    redis_port = int(os.getenv("REDIS_PORT", 6380))
+    r = redis.Redis(host=redis_host, port=redis_port, db=0, decode_responses=True)
+    repo_name = request.repo_url.rstrip('/').split('/')[-1]
+    runs_key = f"review:runs:{repo_name}:{request.pr_number}"
+    await r.sadd(runs_key, time_hash)
+    await r.close()
+
+    background_tasks.add_task(run_review, request.repo_url, request.pr_number, time_hash, request.openai_api_key, request.mcp_server_url)
+    
+    return {"status": "Review started", "time_hash": time_hash, "stream_url": f"/stream/{repo_name}/{request.pr_number}/{time_hash}"}
+
+async def run_review(repo_url: str, pr_number: int, time_hash: str, api_key: str | None = None, mcp_server_url: str | None = None):
+    # Consume the generator to ensure it runs
+    # Note: We need to update orchestrator.review_pr_stream to accept time_hash
+    async for _ in orchestrator.review_pr_stream(repo_url, pr_number, time_hash, api_key, mcp_server_url):
+        pass
+
+@app.get("/runs/{repo_name}/{pr_number}")
+async def list_runs(repo_name: str, pr_number: int):
+    redis_host = os.getenv("REDIS_HOST", "localhost")
+    redis_port = int(os.getenv("REDIS_PORT", 6380))
+    r = redis.Redis(host=redis_host, port=redis_port, db=0, decode_responses=True)
+    runs_key = f"review:runs:{repo_name}:{pr_number}"
+    
+    try:
+        runs = await r.smembers(runs_key)
+        return {"runs": sorted(list(runs), reverse=True)}
+    finally:
+        await r.close()
+
+@app.get("/runs")
+async def list_all_runs():
+    redis_host = os.getenv("REDIS_HOST", "localhost")
+    redis_port = int(os.getenv("REDIS_PORT", 6380))
+    r = redis.Redis(host=redis_host, port=redis_port, db=0, decode_responses=True)
+    
+    try:
+        keys = await r.keys("review:runs:*:*")
+        all_runs = []
+        for key in keys:
+            # key format: review:runs:repo_name:pr_number
+            parts = key.split(":")
+            if len(parts) >= 4:
+                repo_name = parts[2]
+                pr_number = parts[3]
+                runs = await r.smembers(key)
+                for run in runs:
+                    all_runs.append({
+                        "repo_name": repo_name,
+                        "pr_number": pr_number,
+                        "time_hash": run
+                    })
+        
+        # Sort by time_hash descending
+        all_runs.sort(key=lambda x: x["time_hash"], reverse=True)
+        return {"runs": all_runs}
+    finally:
+        await r.close()
+
+@app.get("/stream/{repo_name}/{pr_number}/{time_hash}")
+async def stream_events(repo_name: str, pr_number: int, time_hash: str):
+    redis_host = os.getenv("REDIS_HOST", "localhost")
+    redis_port = int(os.getenv("REDIS_PORT", 6380))
+    r = redis.Redis(host=redis_host, port=redis_port, db=0, decode_responses=True)
+    stream_key = f"review:stream:{repo_name}:{pr_number}:{time_hash}"
+    
+    async def event_generator():
+        last_id = "0-0" # Start from beginning
+        try:
+            while True:
+                # Read new messages
+                streams = await r.xread({stream_key: last_id}, count=1, block=1000)
+                
+                if not streams:
+                    # Send a keep-alive comment to prevent timeout
+                    yield ": keep-alive\n\n"
+                    continue
+
+                for stream_name, messages in streams:
+                    for message_id, data in messages:
+                        last_id = message_id
+                        # Format as SSE
+                        yield f"data: {json.dumps(data)}\n\n"
+                        
+        except asyncio.CancelledError:
+            print("Stream cancelled")
+        finally:
+            await r.close()
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)