Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY pyproject.toml .
+RUN pip install .
+
+COPY . .
+
+CMD ["python", "server.py"]

README.md

@@ -1,10 +1,22 @@
 ---
-title: Tech Wizard Mcp
-emoji: 📚
-colorFrom: red
-colorTo: yellow
+title: Tech-Wizard-MCP
+emoji: 🧙‍♂️
+colorFrom: blue
+colorTo: gray
 sdk: docker
 pinned: false
+app_port: 8000
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Tech Wizard MCP Server
+
+This is the comprehensive 'Tech Wizard' agent, capable of acting as a Software Architect, Senior Engineer, API/Webhooks Specialist, and App Builder.
+
+## Features
+- **System Architecture**: High-level designs and Mermaid diagrams.
+- **API/Webhook Design**: Secure, idiomatic, and reliable patterns.
+- **DNS & Routing**: Strategic domain and SSL orchestration.
+- **Grand Tech Wizard AI**: Powered by OpenAI gpt-4o.
+
+## Deployment
+This Space is configured to run the MCP server.

openai_module.py

@@ -0,0 +1,21 @@
+import os
+from openai import OpenAI
+from typing import Optional
+
+class OpenAIClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
+        self.default_model = "gpt-4o"
+
+    def chat(self, prompt: str, system_instruction: str = "You are the 'Grand Tech Wizard'. You are a master Software Architect, Senior Engineer, API/Webhooks Specialist, and App Builder. You design scalable, secure, and idiomatic technical systems.", model: Optional[str] = None) -> str:
+        try:
+            response = self.client.chat.completions.create(
+                model=model or self.default_model,
+                messages=[
+                    {"role": "system", "content": system_instruction},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Error calling OpenAI API: {str(e)}"

pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "tech-wizard"
+version = "0.1.0"
+description = "Comprehensive Tech Wizard MCP Server (Architect, Engineer, API, Webhooks, Domains, App Builder)"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp[cli]>=1.21.2",
+    "openai>=1.0.0",
+    "python-dotenv>=1.0.0",
+    "pydantic>=2.0.0",
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+tech-wizard = "tech_wizard.server:main"

server.py

@@ -0,0 +1,54 @@
+from mcp.server.fastmcp import FastMCP
+from tech_wizard.tools import TechWizardTools
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Initialize FastMCP
+mcp = FastMCP("Tech-Wizard")
+
+# Initialize Tools
+tech_tools = TechWizardTools()
+
+@mcp.tool()
+def architect_system(requirements: str) -> str:
+    """
+    Design a technical architecture plan (Mermaid diagram, stack, patterns).
+    """
+    return tech_tools.architect_system(requirements)
+
+@mcp.tool()
+def design_api(features: str) -> str:
+    """
+    Design a comprehensive API surface (endpoints, schemas, security).
+    """
+    return tech_tools.design_api(features)
+
+@mcp.tool()
+def setup_webhooks(source_platform: str) -> str:
+    """
+    Generate secure and reliable webhook handler code.
+    """
+    return tech_tools.setup_webhooks(source_platform)
+
+@mcp.tool()
+def configure_dns_routing(domain: str, app_details: str) -> str:
+    """
+    Get a DNS configuration and SSL/TLS routing plan.
+    """
+    return tech_tools.configure_routing(domain, app_details)
+
+@mcp.tool()
+def engineering_consultant(query: str) -> str:
+    """
+    Consult the Grand Tech Wizard for high-level engineering advice.
+    """
+    return tech_tools.llm.chat(query)
+
+def main():
+    mcp.run()
+
+if __name__ == "__main__":
+    main()

tech_kb.py

@@ -0,0 +1,56 @@
+from typing import Dict, Any, List
+
+class TechKnowledgeBase:
+    def __init__(self):
+        self.architect_patterns = {
+            "microservices": "Decoupled services communicating via API/Events. Pros: Scalability. Cons: Complexity.",
+            "serverless": "Event-driven, scale-to-zero logic. Best for intermittent workloads.",
+            "layered_architecture": "Separation of concerns (UI, Domain, Data). Standard for enterprise apps."
+        }
+        
+        self.api_best_practices = {
+            "versioning": "Use URL versioning (e.g., /v1/) or Header versioning.",
+            "security": "Implement OAuth2/OIDC. Use rate limiting and input validation.",
+            "documentation": "OAS3 (Swagger) is the industry standard for REST APIs."
+        }
+        
+        self.webhook_wizardry = {
+            "security": "Verify signatures using HMAC SHA256. Use secret rotation.",
+            "reliability": "Implement exponential backoff retries. Use an idempotency key to prevent double processing.",
+            "payloads": "Keep payloads small; use 'thin' webhooks that prompt a GET request for full data."
+        }
+        
+        self.domain_routing = {
+            "dns_types": {
+                "A": "Points domain to IPv4.",
+                "CNAME": "Alias for another domain (good for CDNs/PaaS).",
+                "TXT": "Used for SPF/DKIM/DMARC and site verification.",
+                "MX": "Mail Exchange records."
+            },
+            "ssl_tls": "Always use Let's Encrypt for automated certificates. Force HTTPS redirection."
+        }
+        
+        self.app_builder_templates = {
+            "fastapi_mcp": "Python-based high performance API with built-in MCP support.",
+            "nextjs_tailwind": "Modern React frontend with utility-first CSS and server-side rendering.",
+            "docker_slim": "Multi-stage builds to keep image size small and secure."
+        }
+
+    def get_info(self, module: str) -> Dict[str, Any]:
+        data = {
+            "architecture": self.architect_patterns,
+            "api": self.api_best_practices,
+            "webhooks": self.webhook_wizardry,
+            "domains": self.domain_routing,
+            "apps": self.app_builder_templates
+        }
+        return data.get(module, {"error": "Module knowledge not found."})
+
+    def get_all(self) -> Dict[str, Any]:
+        return {
+            "architecture": self.architect_patterns,
+            "api": self.api_best_practices,
+            "webhooks": self.webhook_wizardry,
+            "domains": self.domain_routing,
+            "apps": self.app_builder_templates
+        }

tools.py

@@ -0,0 +1,63 @@
+from tech_wizard.tech_kb import TechKnowledgeBase
+from tech_wizard.openai_module import OpenAIClient
+import os
+import json
+
+class TechWizardTools:
+    def __init__(self, openai_api_key=None):
+        self.kb = TechKnowledgeBase()
+        self.llm = OpenAIClient(api_key=openai_api_key or os.getenv("OPENAI_API_KEY"))
+
+    def architect_system(self, requirements: str) -> str:
+        """Design a technical system architecture."""
+        kb_context = self.kb.get_info("architecture")
+        prompt = f"""
+        Requirements: {requirements}
+        Architecture Patterns Knowledge: {json.dumps(kb_context, indent=2)}
+        
+        Please design a technical architecture. Include:
+        1. Recommended Pattern (e.g., Microservices vs Monolith).
+        2. Technology Stack (Frontend, Backend, DB, Cache).
+        3. A Mermaid.js diagram representing the system.
+        4. Scalability and Security considerations.
+        """
+        return self.llm.chat(prompt)
+
+    def design_api(self, features: str) -> str:
+        """Design a secure and versioned API surface."""
+        kb_context = self.kb.get_info("api")
+        prompt = f"""
+        Feature Requirements: {features}
+        API Best Practices: {json.dumps(kb_context, indent=2)}
+        
+        Design a REST or GraphQL API surface. Include:
+        1. Endpoint paths and methods.
+        2. Request/Response schemas (JSON).
+        3. Authentication/Authorization strategy.
+        4. Error handling logic.
+        """
+        return self.llm.chat(prompt)
+
+    def setup_webhooks(self, source_platform: str) -> str:
+        """Generate secure webhook handler logic."""
+        kb_context = self.kb.get_info("webhooks")
+        prompt = f"""
+        Source Platform (e.g., Stripe, GitHub, Shopify): {source_platform}
+        Webhook Knowledge: {json.dumps(kb_context, indent=2)}
+        
+        Generate a secure webhook handler (Python/FastAPI or Node.js). 
+        Must include signature verification, idempotency, and asynchronous processing.
+        """
+        return self.llm.chat(prompt)
+
+    def configure_routing(self, domain: str, app_details: str) -> str:
+        """Design DNS and routing configuration."""
+        kb_context = self.kb.get_info("domains")
+        prompt = f"""
+        Domain: {domain}
+        App/Infrastructure Details: {app_details}
+        Routing Knowledge: {json.dumps(kb_context, indent=2)}
+        
+        Provide a DNS configuration plan (A, CNAME, TXT records) and SSL/TLS strategy.
+        """
+        return self.llm.chat(prompt)