change functionality to add tags to model repos

README.md

@@ -1,5 +1,5 @@
 ---
-title: Mcp Discussion Bot
+title: tag-a-repo bot
 emoji: 👀
 colorFrom: purple
 colorTo: yellow
@@ -10,246 +10,12 @@ pinned: false
 base_path: /gradio
 ---
 
-# 🤖 Hugging Face Discussion Bot
+# HF Tagging Bot
 
-A FastAPI and Gradio application that automatically responds to Hugging Face Hub discussion comments using AI-powered responses via Hugging Face Inference API with MCP integration.
+This is a bot that tags HuggingFace models when they are mentioned in discussions.
 
-## ✨ Features
+## How it works
 
-- **Webhook Integration**: Receives real-time webhooks from Hugging Face Hub when new discussion comments are posted
-- **AI-Powered Responses**: Uses Hugging Face Inference API with MCP support for intelligent, context-aware responses
-- **Interactive Dashboard**: Beautiful Gradio interface to monitor comments and test functionality
-- **Automatic Posting**: Posts AI responses back to the original discussion thread
-- **Testing Tools**: Built-in webhook simulation and AI testing capabilities
-- **MCP Server**: Includes a Model Context Protocol server for advanced tool integration
-
-## 🚀 Quick Start
-
-### 1. Installation
-
-```bash
-# Clone the repository
-git clone <your-repo-url>
-cd mcp-course-unit3-example
-
-# Install dependencies
-pip install -e .
-```
-
-### 2. Environment Setup
-
-Copy the example environment file and configure your API keys:
-
-```bash
-cp env.example .env
-```
-
-Edit `.env` with your credentials:
-
-```env
-# Webhook Configuration
-WEBHOOK_SECRET=your-secure-webhook-secret
-
-# Hugging Face Configuration  
-HF_TOKEN=hf_your_hugging_face_token_here
-
-# Model Configuration (optional)
-HF_MODEL=microsoft/DialoGPT-medium
-HF_PROVIDER=huggingface
-```
-
-### 3. Run the Application
-
-```bash
-python server.py
-```
-
-The application will start on `http://localhost:8000` with:
-- 📊 **Gradio Dashboard**: `http://localhost:8000/gradio`
-- 🔗 **Webhook Endpoint**: `http://localhost:8000/webhook`
-- 📋 **API Documentation**: `http://localhost:8000/docs`
-
-## 🔧 Configuration
-
-### Hugging Face Hub Webhook Setup
-
-1. Go to your Hugging Face repository settings
-2. Navigate to the "Webhooks" section
-3. Create a new webhook with:
-   - **URL**: `https://your-domain.com/webhook`
-   - **Secret**: Same as `WEBHOOK_SECRET` in your `.env`
-   - **Events**: Subscribe to "Community (PR & discussions)"
-
-### Required API Keys
-
-#### Hugging Face Token
-1. Go to [Hugging Face Settings](https://huggingface.co/settings/tokens)
-2. Create a new token with "Write" permissions
-3. Add it to your `.env` as `HF_TOKEN`
-
-## 📊 Dashboard Features
-
-### Recent Comments Tab
-- View all processed discussion comments
-- See AI responses in real-time
-- Refresh and filter capabilities
-
-### Test HF Inference Tab
-- Direct testing of the Hugging Face Inference API
-- Custom prompt input
-- Response preview
-
-### Simulate Webhook Tab
-- Test webhook processing without real HF events
-- Mock discussion scenarios
-- Validate AI response generation
-
-### Configuration Tab
-- View current setup status
-- Check API key configuration
-- Monitor processing statistics
-
-## 🔌 API Endpoints
-
-### POST `/webhook`
-Receives webhooks from Hugging Face Hub.
-
-**Headers:**
-- `X-Webhook-Secret`: Your webhook secret
-
-**Body:** HF Hub webhook payload
-
-### GET `/comments`
-Returns all processed comments and responses.
-
-### GET `/`
-Basic API information and available endpoints.
-
-## 🤖 MCP Server
-
-The application includes a Model Context Protocol (MCP) server that provides tools for:
-
-- **get_discussions**: Retrieve discussions from HF repositories
-- **get_discussion_details**: Get detailed information about specific discussions
-- **comment_on_discussion**: Add comments to discussions
-- **generate_ai_response**: Generate AI responses using HF Inference
-- **respond_to_discussion**: Generate and post AI responses automatically
-
-### Running the MCP Server
-
-```bash
-python mcp_server.py
-```
-
-The MCP server uses stdio transport and can be integrated with MCP clients following the [Tiny Agents pattern](https://huggingface.co/blog/python-tiny-agents).
-
-## 🧪 Testing
-
-### Local Testing
-Use the "Simulate Webhook" tab in the Gradio dashboard to test without real webhooks.
-
-### Webhook Testing
-You can test the webhook endpoint directly:
-
-```bash
-curl -X POST http://localhost:8000/webhook \
-  -H "Content-Type: application/json" \
-  -H "X-Webhook-Secret: your-webhook-secret" \
-  -d '{
-    "event": {"action": "create", "scope": "discussion.comment"},
-    "comment": {
-      "content": "@discussion-bot How do I use this model?",
-      "author": "test-user",
-      "created_at": "2024-01-01T00:00:00Z"
-    },
-    "discussion": {
-      "title": "Test Discussion",
-      "num": 1,
-      "url": {"api": "https://huggingface.co/api/repos/test/repo/discussions"}
-    },
-    "repo": {"name": "test/repo"}
-  }'
-```
-
-## 🏗️ Architecture
-
-```
-┌─────────────────┐    ┌────────────────��┐    ┌─────────────────┐
-│   HF Hub        │───▶│   FastAPI       │───▶│   HF Inference  │
-│   Webhook       │    │   Server        │    │   API           │
-└─────────────────┘    └─────────────────┘    └─────────────────┘
-                              │
-                              ▼
-                       ┌─────────────────┐
-                       │   Gradio        │
-                       │   Dashboard     │
-                       └─────────────────┘
-                              │
-                              ▼
-                       ┌─────────────────┐
-                       │   MCP Server    │
-                       │   (Tools)       │
-                       └─────────────────┘
-```
-
-## 🔒 Security
-
-- Webhook secret verification prevents unauthorized requests
-- Environment variables keep sensitive data secure
-- CORS middleware configured for safe cross-origin requests
-
-## 🚀 Deployment
-
-### Using Docker (Recommended)
-
-```dockerfile
-FROM python:3.11-slim
-
-WORKDIR /app
-COPY . .
-RUN pip install -e .
-
-EXPOSE 8000
-CMD ["python", "server.py"]
-```
-
-### Using Cloud Platforms
-
-The application can be deployed on:
-- **Hugging Face Spaces** (recommended for HF integration)
-- **Railway**
-- **Render**
-- **Heroku**
-- **AWS/GCP/Azure**
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests if applicable
-5. Submit a pull request
-
-## 📝 License
-
-This project is licensed under the MIT License.
-
-## 🆘 Support
-
-If you encounter issues:
-
-1. Check the Configuration tab in the dashboard
-2. Verify your API keys are correct
-3. Ensure webhook URL is accessible
-4. Check the application logs
-
-For additional help, please open an issue in the repository.
-
-## 🔗 Related Links
-
-- [Hugging Face Webhooks Guide](https://huggingface.co/docs/hub/en/webhooks-guide-discussion-bot)
-- [Hugging Face Hub Python Library](https://huggingface.co/docs/huggingface_hub/en/guides/community)
-- [Tiny Agents in Python Blog Post](https://huggingface.co/blog/python-tiny-agents)
-- [FastAPI Documentation](https://fastapi.tiangolo.com/)
-- [Gradio Documentation](https://gradio.app/)
-- [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
+1. The bot listens to discussions on the HuggingFace Hub
+2. When a discussion is created, the bot checks for tag mentions in the comment
+3. If a tag is mentioned, the bot adds the tag to the model repository via a PR

app.py

@@ -1,6 +1,8 @@
 import os
+import re
+import json
 from datetime import datetime
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Literal
 
 from fastapi import FastAPI, Request, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
@@ -16,14 +18,56 @@ load_dotenv()
 WEBHOOK_SECRET = os.getenv("WEBHOOK_SECRET", "your-webhook-secret")
 HF_TOKEN = os.getenv("HF_TOKEN")
 HF_MODEL = os.getenv("HF_MODEL", "microsoft/DialoGPT-medium")
-HF_PROVIDER = os.getenv("HF_PROVIDER", "huggingface")
+# Use a valid provider literal from the documentation
+DEFAULT_PROVIDER: Literal["hf-inference"] = "hf-inference"
+HF_PROVIDER = os.getenv("HF_PROVIDER", DEFAULT_PROVIDER)
 
-# Simple storage for processed comments
-comments_store: List[Dict[str, Any]] = []
+# Simple storage for processed tag operations
+tag_operations_store: List[Dict[str, Any]] = []
 
 # Agent instance
 agent_instance: Optional[Agent] = None
 
+# Common ML tags that we recognize for auto-tagging
+RECOGNIZED_TAGS = {
+    "pytorch",
+    "tensorflow",
+    "jax",
+    "transformers",
+    "diffusers",
+    "text-generation",
+    "text-classification",
+    "question-answering",
+    "text-to-image",
+    "image-classification",
+    "object-detection",
+    "conversational",
+    "fill-mask",
+    "token-classification",
+    "translation",
+    "summarization",
+    "feature-extraction",
+    "sentence-similarity",
+    "zero-shot-classification",
+    "image-to-text",
+    "automatic-speech-recognition",
+    "audio-classification",
+    "voice-activity-detection",
+    "depth-estimation",
+    "image-segmentation",
+    "video-classification",
+    "reinforcement-learning",
+    "tabular-classification",
+    "tabular-regression",
+    "time-series-forecasting",
+    "graph-ml",
+    "robotics",
+    "computer-vision",
+    "nlp",
+    "cv",
+    "multimodal",
+}
+
 
 class WebhookEvent(BaseModel):
     event: Dict[str, str]
@@ -32,7 +76,7 @@ class WebhookEvent(BaseModel):
     repo: Dict[str, str]
 
 
-app = FastAPI(title="HF Discussion Bot")
+app = FastAPI(title="HF Tagging Bot")
 app.add_middleware(CORSMiddleware, allow_origins=["*"])
 
 
@@ -42,12 +86,17 @@ async def get_agent():
     if agent_instance is None and HF_TOKEN:
         agent_instance = Agent(
             model=HF_MODEL,
-            provider=HF_PROVIDER,
+            provider=DEFAULT_PROVIDER,
             api_key=HF_TOKEN,
             servers=[
                 {
                     "type": "stdio",
-                    "config": {"command": "python", "args": ["mcp_server.py"]},
+                    "config": {
+                        "command": "python",
+                        "args": ["mcp_server.py"],
+                        "cwd": ".",  # Ensure correct working directory
+                        "env": {"HF_TOKEN": HF_TOKEN} if HF_TOKEN else {},
+                    },
                 }
             ],
         )
@@ -55,45 +104,129 @@ async def get_agent():
     return agent_instance
 
 
+def extract_tags_from_text(text: str) -> List[str]:
+    """Extract potential tags from discussion text"""
+    text_lower = text.lower()
+
+    # Look for explicit tag mentions like "tag: pytorch" or "#pytorch"
+    explicit_tags = []
+
+    # Pattern 1: "tag: something" or "tags: something"
+    tag_pattern = r"tags?:\s*([a-zA-Z0-9-_,\s]+)"
+    matches = re.findall(tag_pattern, text_lower)
+    for match in matches:
+        # Split by comma and clean up
+        tags = [tag.strip() for tag in match.split(",")]
+        explicit_tags.extend(tags)
+
+    # Pattern 2: "#hashtag" style
+    hashtag_pattern = r"#([a-zA-Z0-9-_]+)"
+    hashtag_matches = re.findall(hashtag_pattern, text_lower)
+    explicit_tags.extend(hashtag_matches)
+
+    # Pattern 3: Look for recognized tags mentioned in natural text
+    mentioned_tags = []
+    for tag in RECOGNIZED_TAGS:
+        if tag in text_lower:
+            mentioned_tags.append(tag)
+
+    # Combine and deduplicate
+    all_tags = list(set(explicit_tags + mentioned_tags))
+
+    # Filter to only include recognized tags or explicitly mentioned ones
+    valid_tags = []
+    for tag in all_tags:
+        if tag in RECOGNIZED_TAGS or tag in explicit_tags:
+            valid_tags.append(tag)
+
+    return valid_tags
+
+
 async def process_webhook_comment(webhook_data: Dict[str, Any]):
-    """Process webhook using Agent with MCP tools"""
+    """Process webhook to detect and add tags"""
     comment_content = webhook_data["comment"]["content"]
     discussion_title = webhook_data["discussion"]["title"]
     repo_name = webhook_data["repo"]["name"]
     discussion_num = webhook_data["discussion"]["num"]
+    comment_author = webhook_data["comment"]["author"]
 
-    agent = await get_agent()
-    if not agent:
-        ai_response = "Error: Agent not configured (missing HF_TOKEN)"
-    else:
-        # Use Agent to respond to the discussion
-        prompt = f"""
-        Please respond to this HuggingFace discussion comment using the available tools.
-        
-        Repository: {repo_name}
-        Discussion: {discussion_title} (#{discussion_num})
-        Comment: {comment_content}
-        
-        First use generate_discussion_response to create a helpful response, then use post_discussion_comment to post it.
-        """
-
-        try:
-            response_parts = []
-            async for item in agent.run(prompt):
-                # Collect the agent's response
-                if hasattr(item, "content") and item.content:
-                    response_parts.append(item.content)
-                elif isinstance(item, str):
-                    response_parts.append(item)
-
-            ai_response = (
-                " ".join(response_parts) if response_parts else "No response generated"
-            )
-        except Exception as e:
-            ai_response = f"Error using agent: {str(e)}"
+    # Extract potential tags from the comment and discussion title
+    comment_tags = extract_tags_from_text(comment_content)
+    title_tags = extract_tags_from_text(discussion_title)
+    all_tags = list(set(comment_tags + title_tags))
+
+    result_messages = []
 
-    # Store the interaction with reply link
-    discussion_url = f"https://huggingface.co/{repo_name}/discussions/{discussion_num}"
+    if not all_tags:
+        result_messages.append("No recognizable tags found in the discussion.")
+    else:
+        agent = await get_agent()
+        if not agent:
+            msg = "Error: Agent not configured (missing HF_TOKEN)"
+            result_messages.append(msg)
+        else:
+            # Process each tag
+            for tag in all_tags:
+                try:
+                    # Get response from agent
+                    responses = []
+                    prompt = (
+                        f"Add the tag '{tag}' to repository {repo_name} "
+                        "using add_new_tag"
+                    )
+
+                    async for item in agent.run(prompt):
+                        # Just collect the response content
+                        responses.append(str(item))
+
+                    response_text = " ".join(responses) if responses else "Completed"
+
+                    # Try to parse JSON from response if possible
+                    try:
+                        # Look for JSON in the response
+                        json_found = False
+                        for response_part in responses:
+                            response_str = str(response_part)
+                            if "{" in response_str and "}" in response_str:
+                                # Try to extract JSON from the response
+                                start_idx = response_str.find("{")
+                                end_idx = response_str.rfind("}") + 1
+                                json_str = response_str[start_idx:end_idx]
+
+                                try:
+                                    json_response = json.loads(json_str)
+                                    status = json_response.get("status")
+                                    if status == "success":
+                                        pr_url = json_response.get("pr_url", "")
+                                        msg = f"Tag '{tag}': PR created - {pr_url}"
+                                    elif status == "already_exists":
+                                        msg = f"Tag '{tag}': Already exists"
+                                    else:
+                                        tag_msg = json_response.get(
+                                            "message", "Processed"
+                                        )
+                                        msg = f"Tag '{tag}': {tag_msg}"
+                                    json_found = True
+                                    break
+                                except json.JSONDecodeError:
+                                    continue
+
+                        if not json_found:
+                            # If no JSON found, use the response as is
+                            msg = f"Tag '{tag}': {response_text}"
+
+                    except Exception as parse_error:
+                        msg = f"Tag '{tag}': Response parse error - {response_text}"
+
+                    result_messages.append(msg)
+
+                except Exception as e:
+                    error_msg = f"Error processing tag '{tag}': {str(e)}"
+                    result_messages.append(error_msg)
+
+    # Store the interaction
+    base_url = "https://huggingface.co"
+    discussion_url = f"{base_url}/{repo_name}/discussions/{discussion_num}"
 
     interaction = {
         "timestamp": datetime.now().isoformat(),
@@ -102,12 +235,13 @@ async def process_webhook_comment(webhook_data: Dict[str, Any]):
         "discussion_num": discussion_num,
         "discussion_url": discussion_url,
         "original_comment": comment_content,
-        "ai_response": ai_response,
-        "comment_author": webhook_data["comment"]["author"],
+        "comment_author": comment_author,
+        "detected_tags": all_tags,
+        "results": result_messages,
     }
 
-    comments_store.append(interaction)
-    return ai_response
+    tag_operations_store.append(interaction)
+    return " | ".join(result_messages)
 
 
 @app.post("/webhook")
@@ -120,7 +254,8 @@ async def webhook_handler(request: Request, background_tasks: BackgroundTasks):
     payload = await request.json()
     event = payload.get("event", {})
 
-    if event.get("action") == "create" and event.get("scope") == "discussion.comment":
+    scope_check = event.get("scope") == "discussion.comment"
+    if event.get("action") == "create" and scope_check:
         background_tasks.add_task(process_webhook_comment, payload)
         return {"status": "processing"}
 
@@ -143,40 +278,64 @@ async def simulate_webhook(
         },
         "discussion": {
             "title": discussion_title,
-            "num": len(comments_store) + 1,
+            "num": len(tag_operations_store) + 1,
         },
         "repo": {"name": repo_name},
     }
 
     response = await process_webhook_comment(mock_payload)
-    return f"✅ Processed! AI Response: {response}"
+    return f"✅ Processed! Results: {response}"
 
 
 def create_gradio_app():
     """Create Gradio interface"""
-    with gr.Blocks(title="HF Discussion Bot", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🤖 HF Discussion Bot Dashboard")
-        gr.Markdown("*Powered by HuggingFace Tiny Agents + FastMCP*")
+    with gr.Blocks(title="HF Tagging Bot", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🏷️ HF Tagging Bot Dashboard")
+        gr.Markdown("*Automatically adds tags to models when mentioned in discussions*")
+
+        gr.Markdown("""
+        ## How it works:
+        - Monitors HuggingFace Hub discussions
+        - Detects tag mentions in comments (e.g., "tag: pytorch", 
+          "#transformers")
+        - Automatically adds recognized tags to the model repository
+        - Supports common ML tags like: pytorch, tensorflow, 
+          text-generation, etc.
+        """)
 
         with gr.Column():
-            sim_repo = gr.Textbox(label="Repository", value="microsoft/DialoGPT-medium")
-            sim_title = gr.Textbox(label="Discussion Title", value="Test Discussion")
+            sim_repo = gr.Textbox(
+                label="Repository",
+                value="burtenshaw/play-mcp-repo-bot",
+                placeholder="username/model-name",
+            )
+            sim_title = gr.Textbox(
+                label="Discussion Title",
+                value="Add pytorch tag",
+                placeholder="Discussion title",
+            )
             sim_comment = gr.Textbox(
                 label="Comment",
                 lines=3,
-                value="How do I use this model?",
+                value="This model should have tags: pytorch, text-generation",
+                placeholder="Comment mentioning tags...",
             )
-            sim_btn = gr.Button("📤 Test Webhook")
+            sim_btn = gr.Button("🏷️ Test Tag Detection")
 
         with gr.Column():
             sim_result = gr.Textbox(label="Result", lines=8)
 
         sim_btn.click(
-            fn=simulate_webhook,
+            simulate_webhook,
             inputs=[sim_repo, sim_title, sim_comment],
-            outputs=[sim_result],
+            outputs=sim_result,
         )
 
+        gr.Markdown(f"""
+        ## Recognized Tags:
+        {", ".join(sorted(RECOGNIZED_TAGS))}
+        """)
+
     return demo
 
 
@@ -186,7 +345,7 @@ app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
 
 
 if __name__ == "__main__":
-    print("🚀 Starting HF Discussion Bot with Tiny Agents...")
-    print("📊 Dashboard: http://localhost:7860")
+    print("🚀 Starting HF Tagging Bot...")
+    print("📊 Dashboard: http://localhost:7860/gradio")
     print("🔗 Webhook: http://localhost:7860/webhook")
     uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)

mcp_server.py

@@ -1,80 +1,144 @@
 #!/usr/bin/env python3
 """
-Simplified MCP Server for HuggingFace Hub Operations using FastMCP
+Simplified MCP Server for HuggingFace Hub Tagging Operations using FastMCP
 """
 
 import os
+import json
 from fastmcp import FastMCP
-from huggingface_hub import comment_discussion, InferenceClient
+from huggingface_hub import HfApi, model_info, ModelCard, ModelCardData
+from huggingface_hub.utils import HfHubHTTPError
 from dotenv import load_dotenv
 
 load_dotenv()
 
 # Configuration
 HF_TOKEN = os.getenv("HF_TOKEN")
-DEFAULT_MODEL = os.getenv("HF_MODEL", "Qwen/Qwen2.5-72B-Instruct")
 
-# Initialize HF client
-inference_client = (
-    InferenceClient(model=DEFAULT_MODEL, token=HF_TOKEN) if HF_TOKEN else None
-)
+# Initialize HF API client
+hf_api = HfApi(token=HF_TOKEN) if HF_TOKEN else None
 
 # Create the FastMCP server
-mcp = FastMCP("hf-discussion-bot")
+mcp = FastMCP("hf-tagging-bot")
 
 
 @mcp.tool()
-def generate_discussion_response(
-    discussion_title: str, comment_content: str, repo_name: str
-) -> str:
-    """Generate AI response for a HuggingFace discussion comment"""
-    if not inference_client:
-        return "Error: HF token not configured for inference"
-
-    prompt = f"""
-    Discussion: {discussion_title}
-    Repository: {repo_name}
-    Comment: {comment_content}
-    
-    Provide a helpful response to this comment.
-    """
+def get_current_tags(repo_id: str) -> str:
+    """Get current tags from a HuggingFace model repository"""
+    if not hf_api:
+        return json.dumps({"error": "HF token not configured"})
 
     try:
-        messages = [
-            {
-                "role": "system",
-                "content": ("You are a helpful AI assistant for ML discussions."),
-            },
-            {"role": "user", "content": prompt},
-        ]
-
-        response = inference_client.chat_completion(messages=messages, max_tokens=150)
-        content = response.choices[0].message.content
-        ai_response = content.strip() if content else "No response generated"
-        return ai_response
+        info = model_info(repo_id=repo_id, token=HF_TOKEN)
+        current_tags = info.tags if info.tags else []
+
+        result = {
+            "status": "success",
+            "repo_id": repo_id,
+            "current_tags": current_tags,
+            "count": len(current_tags),
+        }
+        return json.dumps(result)
 
     except Exception as e:
-        return f"Error generating response: {str(e)}"
+        error_result = {"status": "error", "repo_id": repo_id, "error": str(e)}
+        return json.dumps(error_result)
 
 
 @mcp.tool()
-def post_discussion_comment(repo_id: str, discussion_num: int, comment: str) -> str:
-    """Post a comment to a HuggingFace discussion"""
-    if not HF_TOKEN:
-        return "Error: HF token not configured"
+def add_new_tag(repo_id: str, new_tag: str) -> str:
+    """Add a new tag to a HuggingFace model repository via PR"""
+    if not hf_api:
+        return json.dumps({"error": "HF token not configured"})
 
     try:
-        comment_discussion(
+        # Get current model info and tags
+        info = model_info(repo_id=repo_id, token=HF_TOKEN)
+        current_tags = info.tags if info.tags else []
+
+        # Check if tag already exists
+        if new_tag in current_tags:
+            result = {
+                "status": "already_exists",
+                "repo_id": repo_id,
+                "tag": new_tag,
+                "message": f"Tag '{new_tag}' already exists",
+            }
+            return json.dumps(result)
+
+        # Add the new tag to existing tags
+        updated_tags = current_tags + [new_tag]
+
+        # Create model card content with updated tags
+        try:
+            # Load existing model card
+            card = ModelCard.load(repo_id, token=HF_TOKEN)
+            if not hasattr(card, "data") or card.data is None:
+                card.data = ModelCardData()
+        except HfHubHTTPError:
+            # Create new model card if none exists
+            card = ModelCard("")
+            card.data = ModelCardData()
+
+        # Update tags - create new ModelCardData with updated tags
+        card_dict = card.data.to_dict()
+        card_dict["tags"] = updated_tags
+        card.data = ModelCardData(**card_dict)
+
+        # Create a pull request with the updated model card
+        pr_title = f"Add '{new_tag}' tag"
+        pr_description = f"""
+## Add tag: {new_tag}
+
+This PR adds the `{new_tag}` tag to the model repository.
+
+**Changes:**
+- Added `{new_tag}` to model tags
+- Updated from {len(current_tags)} to {len(updated_tags)} tags
+
+**Current tags:** {", ".join(current_tags) if current_tags else "None"}
+**New tags:** {", ".join(updated_tags)}
+"""
+
+        # Create commit with updated model card using CommitOperationAdd
+        from huggingface_hub import CommitOperationAdd
+
+        commit_info = hf_api.create_commit(
             repo_id=repo_id,
-            discussion_num=discussion_num,
-            comment=comment,
+            operations=[
+                CommitOperationAdd(
+                    path_in_repo="README.md", path_or_fileobj=str(card).encode("utf-8")
+                )
+            ],
+            commit_message=pr_title,
+            commit_description=pr_description,
             token=HF_TOKEN,
+            create_pr=True,
         )
-        success_msg = f"Successfully posted comment to discussion #{discussion_num}"
-        return success_msg
+
+        # Extract PR URL from commit info
+        pr_url_attr = commit_info.pr_url
+        pr_url = pr_url_attr if hasattr(commit_info, "pr_url") else str(commit_info)
+
+        result = {
+            "status": "success",
+            "repo_id": repo_id,
+            "tag": new_tag,
+            "pr_url": pr_url,
+            "previous_tags": current_tags,
+            "new_tags": updated_tags,
+            "message": f"Created PR to add tag '{new_tag}'",
+        }
+        return json.dumps(result)
 
     except Exception as e:
-        return f"Error posting comment: {str(e)}"
+        error_result = {
+            "status": "error",
+            "repo_id": repo_id,
+            "tag": new_tag,
+            "error": str(e),
+        }
+        return json.dumps(error_result)
 
 
 if __name__ == "__main__":