Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| from transformers import pipeline | |
| from fpdf import FPDF | |
| import pandas as pd | |
| import tempfile | |
| import os | |
| import re | |
| from datetime import datetime | |
| # ───────────────────────────────────────── | |
| # Load Hugging Face Models (cached after first run) | |
| # ───────────────────────────────────────── | |
| print("Loading models...") | |
| classifier = pipeline( | |
| "zero-shot-classification", | |
| model="facebook/bart-large-mnli" | |
| ) | |
| summarizer = pipeline( | |
| "summarization", | |
| model="facebook/bart-large-cnn", | |
| min_length=60, | |
| max_length=180 | |
| ) | |
| print("Models ready.") | |
| # ───────────────────────────────────────── | |
| # Constants | |
| # ───────────────────────────────────────── | |
| REQUIREMENT_CATEGORIES = [ | |
| "Data Integration & ETL", | |
| "AI & Machine Learning", | |
| "Workflow Automation", | |
| "Cloud Infrastructure", | |
| "Security & Compliance", | |
| "User Interface & Experience", | |
| "API & Microservices", | |
| "Analytics & Reporting", | |
| "Legacy System Migration", | |
| "Real-time Processing", | |
| ] | |
| ARCHITECTURE_PATTERNS = { | |
| "Data Integration & ETL": ("Data Pipeline Architecture", ["Apache Kafka", "Airflow", "dbt", "PostgreSQL"]), | |
| "AI & Machine Learning": ("ML Platform Architecture", ["Hugging Face", "FastAPI", "MLflow", "Docker"]), | |
| "Workflow Automation": ("Event-Driven Architecture", ["n8n", "Temporal", "RabbitMQ", "FastAPI"]), | |
| "Cloud Infrastructure": ("Cloud-Native Architecture", ["AWS ECS", "Terraform", "K8s", "CloudWatch"]), | |
| "Security & Compliance": ("Zero-Trust Architecture", ["Vault", "Keycloak", "OAuth2", "WAF"]), | |
| "User Interface & Experience": ("Micro-Frontend Architecture", ["React", "Next.js", "Tailwind", "Vercel"]), | |
| "API & Microservices": ("API Gateway Architecture", ["Kong", "FastAPI", "gRPC", "Redis"]), | |
| "Analytics & Reporting": ("Data Warehouse Architecture", ["Snowflake", "dbt", "Metabase", "Redshift"]), | |
| "Legacy System Migration": ("Strangler Fig Architecture", ["API Adapter Layer", "Kafka", "Docker", "PostgreSQL"]), | |
| "Real-time Processing": ("Stream Processing Architecture", ["Apache Flink", "Kafka Streams", "Redis", "InfluxDB"]), | |
| } | |
| FITGAP_COMPONENTS = [ | |
| "Authentication & Access Control", | |
| "Data Ingestion Pipeline", | |
| "AI / ML Inference Layer", | |
| "Reporting & Dashboard", | |
| "API Integration Layer", | |
| "Notification & Alerting", | |
| "Audit Logging", | |
| "Scalability & Load Balancing", | |
| ] | |
| # ───────────────────────────────────────── | |
| # Tab 1 — Requirement Analyzer | |
| # ───────────────────────────────────────── | |
| def analyze_requirements(client_name, industry, requirements_text, existing_systems): | |
| if not requirements_text.strip(): | |
| return "⚠️ Please enter client requirements.", None | |
| # Zero-shot classification | |
| clf_result = classifier( | |
| requirements_text, | |
| candidate_labels=REQUIREMENT_CATEGORIES, | |
| multi_label=True | |
| ) | |
| # Summarize requirements | |
| safe_text = requirements_text[:1024] | |
| try: | |
| summary_result = summarizer(safe_text, truncation=True) | |
| summary = summary_result[0]["summary_text"] | |
| except Exception: | |
| summary = requirements_text[:300] + "..." | |
| # Complexity score | |
| top_scores = clf_result["scores"][:3] | |
| avg_score = sum(top_scores) / len(top_scores) | |
| complexity = "🟢 Low" if avg_score < 0.45 else ("🟡 Medium" if avg_score < 0.70 else "🔴 High") | |
| # Build output | |
| lines = [] | |
| lines.append(f"## 📋 Requirement Analysis — {client_name or 'Client'}") | |
| lines.append(f"**Industry:** {industry or 'Not specified'}") | |
| lines.append(f"**Existing Systems:** {existing_systems or 'Not specified'}") | |
| lines.append("") | |
| lines.append("### 📝 Executive Summary") | |
| lines.append(summary) | |
| lines.append("") | |
| lines.append("### 🏷️ Requirement Categories (Confidence)") | |
| rows = [] | |
| for label, score in zip(clf_result["labels"], clf_result["scores"]): | |
| bar = "█" * int(score * 20) + "░" * (20 - int(score * 20)) | |
| emoji = "✅" if score > 0.6 else ("🔶" if score > 0.35 else "⬜") | |
| lines.append(f"{emoji} **{label}** — {score:.0%} `{bar}`") | |
| rows.append({"Category": label, "Confidence": f"{score:.0%}", "Priority": emoji}) | |
| lines.append("") | |
| lines.append(f"### ⚙️ Solution Complexity: {complexity}") | |
| lines.append("") | |
| lines.append("### 🎯 Top 3 Focus Areas") | |
| for i, (label, score) in enumerate(zip(clf_result["labels"][:3], clf_result["scores"][:3]), 1): | |
| lines.append(f"{i}. **{label}** ({score:.0%} confidence)") | |
| df = pd.DataFrame(rows) | |
| return "\n".join(lines), df | |
| # ───────────────────────────────────────── | |
| # Tab 2 — Solution Architect | |
| # ───────────────────────────────────────── | |
| def generate_architecture(client_name, requirements_text, timeline_weeks, budget): | |
| if not requirements_text.strip(): | |
| return "⚠️ Please enter requirements first." | |
| clf_result = classifier( | |
| requirements_text, | |
| candidate_labels=REQUIREMENT_CATEGORIES, | |
| multi_label=True | |
| ) | |
| top_labels = clf_result["labels"][:3] | |
| top_scores = clf_result["scores"][:3] | |
| primary_label = top_labels[0] | |
| pattern, tech_stack = ARCHITECTURE_PATTERNS.get( | |
| primary_label, | |
| ("Modular Monolith Architecture", ["Python", "FastAPI", "PostgreSQL", "Docker"]) | |
| ) | |
| weeks = int(timeline_weeks) if timeline_weeks else 12 | |
| lines = [] | |
| lines.append(f"## 🏗️ Solution Architecture — {client_name or 'Client'}") | |
| lines.append(f"**Recommended Pattern:** `{pattern}`") | |
| lines.append(f"**Timeline:** {weeks} weeks **Budget:** {budget or 'Not specified'}") | |
| lines.append("") | |
| lines.append("### 🔩 Architecture Components") | |
| component_map = { | |
| "Data Integration & ETL": [("Ingestion Layer", "Kafka / Airflow DAGs"), ("Transform Layer", "dbt + Pandas"), ("Storage Layer", "PostgreSQL + S3")], | |
| "AI & Machine Learning": [("Model Serving", "FastAPI + Hugging Face Inference"), ("Experiment Tracking", "MLflow"), ("Data Versioning", "DVC + S3")], | |
| "Workflow Automation": [("Orchestrator", "Temporal / n8n"), ("Event Bus", "RabbitMQ"), ("State Store", "Redis")], | |
| "Cloud Infrastructure": [("Compute", "AWS ECS / EKS"), ("IaC", "Terraform"), ("Monitoring", "CloudWatch + Grafana")], | |
| "Security & Compliance": [("Identity Provider", "Keycloak / Auth0"), ("Secrets Management", "HashiCorp Vault"), ("Audit Trail", "Elasticsearch")], | |
| "API & Microservices": [("Gateway", "Kong / AWS API Gateway"), ("Services", "FastAPI Microservices"), ("Cache", "Redis")], | |
| "Analytics & Reporting": [("Warehouse", "Snowflake / Redshift"), ("Transform", "dbt"), ("Viz", "Metabase / Superset")], | |
| "Legacy System Migration": [("Adapter Layer", "REST Wrapper API"), ("Event Bridge", "Kafka"), ("Parallel Run", "Feature Flags")], | |
| "Real-time Processing": [("Stream Processor", "Apache Flink"), ("Message Bus", "Kafka"), ("Time-Series DB", "InfluxDB")], | |
| "User Interface & Experience": [("Frontend", "Next.js + Tailwind"), ("State Mgmt", "Zustand / Redux"), ("CDN", "Cloudflare")], | |
| } | |
| components = component_map.get(primary_label, [ | |
| ("Backend", "FastAPI"), ("Database", "PostgreSQL"), ("Cache", "Redis") | |
| ]) | |
| for name, tech in components: | |
| lines.append(f"- **{name}:** `{tech}`") | |
| lines.append("") | |
| lines.append("### 🔄 Data Flow") | |
| data_flows = [ | |
| "1. Client request enters via API Gateway with auth validation", | |
| "2. Request routed to appropriate microservice", | |
| "3. Business logic executed; data retrieved from primary store", | |
| "4. AI/ML inference called where applicable", | |
| "5. Response formatted and returned; event logged to audit trail", | |
| "6. Async background jobs triggered for downstream processing", | |
| ] | |
| for flow in data_flows: | |
| lines.append(flow) | |
| lines.append("") | |
| lines.append("### 📅 Phased Delivery Plan") | |
| phase_weeks = max(2, weeks // 3) | |
| lines.append(f"- **Phase 1 — Discovery & POC** (Weeks 1–{phase_weeks}): Requirements validation, prototype core components") | |
| lines.append(f"- **Phase 2 — Pilot Build** (Weeks {phase_weeks+1}–{phase_weeks*2}): Build integrations, internal testing, stakeholder demos") | |
| lines.append(f"- **Phase 3 — Production** (Weeks {phase_weeks*2+1}–{weeks}): Hardening, security review, go-live, handover") | |
| lines.append("") | |
| lines.append("### 🛠️ Recommended Tech Stack") | |
| for tech in tech_stack: | |
| lines.append(f"- `{tech}`") | |
| lines.append("") | |
| lines.append("### 📊 Secondary Architecture Concerns") | |
| for label, score in zip(top_labels[1:], top_scores[1:]): | |
| p2, _ = ARCHITECTURE_PATTERNS.get(label, ("Modular Design", [])) | |
| lines.append(f"- **{label}** ({score:.0%}): Consider {p2} patterns for this layer") | |
| return "\n".join(lines) | |
| # ───────────────────────────────────────── | |
| # Tab 3 — Fit-Gap Analyzer | |
| # ───────────────────────────────────────── | |
| def run_fitgap(client_name, requirements_text, available_capabilities): | |
| if not requirements_text.strip(): | |
| return "⚠️ Please enter requirements.", None | |
| rows = [] | |
| lines = [] | |
| lines.append(f"## 🔍 Fit-Gap Analysis — {client_name or 'Client'}") | |
| lines.append("") | |
| caps_lower = (available_capabilities or "").lower() | |
| for component in FITGAP_COMPONENTS: | |
| result = classifier( | |
| f"{requirements_text}\n\nDoes this require: {component}?", | |
| candidate_labels=["required", "not required"], | |
| ) | |
| required = result["labels"][0] == "required" | |
| confidence = result["scores"][0] | |
| keyword = component.lower().split()[0] | |
| platform_has = keyword in caps_lower | |
| if required and platform_has: | |
| status, action = "✅ FIT", "No action needed" | |
| elif required and not platform_has: | |
| status, action = "🔴 GAP", "Build / procure this capability" | |
| elif not required and platform_has: | |
| status, action = "🟡 OPTIONAL", "Available but not required — disable to reduce cost" | |
| else: | |
| status, action = "⬜ N/A", "Not applicable for this engagement" | |
| lines.append(f"**{component}** → {status} ({confidence:.0%} confidence)") | |
| lines.append(f" ↳ _{action}_") | |
| lines.append("") | |
| rows.append({ | |
| "Component": component, | |
| "Status": status, | |
| "Confidence": f"{confidence:.0%}", | |
| "Action": action, | |
| }) | |
| gaps = sum(1 for r in rows if "GAP" in r["Status"]) | |
| fits = sum(1 for r in rows if "FIT" in r["Status"]) | |
| options = sum(1 for r in rows if "OPTIONAL" in r["Status"]) | |
| lines.append("---") | |
| lines.append(f"### 📊 Summary: {fits} Fit | {gaps} Gap(s) | {options} Optional") | |
| if gaps == 0: | |
| lines.append("✅ **Platform is fully capable of meeting requirements.**") | |
| elif gaps <= 2: | |
| lines.append(f"🟡 **Minor gaps found. {gaps} component(s) need to be built or procured.**") | |
| else: | |
| lines.append(f"🔴 **Significant gaps found. Recommend phased implementation to address {gaps} missing components.**") | |
| df = pd.DataFrame(rows) | |
| return "\n".join(lines), df | |
| # ───────────────────────────────────────── | |
| # Tab 4 — Deployment Report Generator | |
| # ───────────────────────────────────────── | |
| def generate_report(client_name, industry, requirements_text, existing_systems, | |
| available_capabilities, timeline_weeks, budget): | |
| if not client_name.strip() or not requirements_text.strip(): | |
| return None, "⚠️ Please provide at least Client Name and Requirements." | |
| # Run all analyses | |
| analysis_md, _ = analyze_requirements(client_name, industry, requirements_text, existing_systems) | |
| architecture_md = generate_architecture(client_name, requirements_text, timeline_weeks, budget) | |
| fitgap_md, df = run_fitgap(client_name, requirements_text, available_capabilities) | |
| def strip_md(text): | |
| text = re.sub(r"[#*`_~\[\]█░✅🔴🟡🟢⬜🔶🏗️📋📝🏷️⚙️🎯🔩🔄📅🛠️📊🔍→↳]", "", text) | |
| return text.strip() | |
| pdf = FPDF() | |
| pdf.set_auto_page_break(auto=True, margin=15) | |
| pdf.add_page() | |
| # Header | |
| pdf.set_fill_color(26, 82, 118) | |
| pdf.rect(0, 0, 210, 28, "F") | |
| pdf.set_text_color(255, 255, 255) | |
| pdf.set_font("Helvetica", "B", 18) | |
| pdf.set_y(8) | |
| pdf.cell(0, 10, "ForwardDeployAI - Deployment Readiness Report", ln=True, align="C") | |
| pdf.set_font("Helvetica", "", 10) | |
| pdf.cell(0, 6, f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')} | Client: {client_name}", ln=True, align="C") | |
| pdf.set_text_color(0, 0, 0) | |
| pdf.ln(10) | |
| def section(title): | |
| pdf.set_fill_color(240, 248, 255) | |
| pdf.set_font("Helvetica", "B", 13) | |
| pdf.set_text_color(26, 82, 118) | |
| pdf.cell(0, 9, title, ln=True, fill=True) | |
| pdf.set_text_color(0, 0, 0) | |
| pdf.ln(2) | |
| def body(text, size=10): | |
| pdf.set_font("Helvetica", "", size) | |
| for line in text.splitlines(): | |
| clean = strip_md(line).strip() | |
| if not clean: | |
| pdf.ln(2) | |
| continue | |
| try: | |
| pdf.multi_cell(0, 6, clean) | |
| except Exception: | |
| pass | |
| # Section 1 — Client Overview | |
| section("1. Client Overview") | |
| pdf.set_font("Helvetica", "", 10) | |
| overview = ( | |
| f"Client Name : {client_name}\n" | |
| f"Industry : {industry or 'Not specified'}\n" | |
| f"Existing Systems: {existing_systems or 'Not specified'}\n" | |
| f"Budget Range : {budget or 'Not specified'}\n" | |
| f"Timeline : {timeline_weeks or 'Not specified'} weeks" | |
| ) | |
| for line in overview.splitlines(): | |
| pdf.cell(0, 7, line, ln=True) | |
| pdf.ln(4) | |
| # Section 2 — Requirement Analysis | |
| section("2. Requirement Analysis") | |
| body(analysis_md) | |
| pdf.ln(4) | |
| # Section 3 — Solution Architecture | |
| section("3. Solution Architecture") | |
| body(architecture_md) | |
| pdf.ln(4) | |
| # Section 4 — Fit-Gap Analysis | |
| section("4. Fit-Gap Analysis") | |
| body(fitgap_md) | |
| if df is not None and not df.empty: | |
| pdf.ln(4) | |
| pdf.set_font("Helvetica", "B", 9) | |
| col_w = [70, 28, 28, 64] | |
| headers = ["Component", "Status", "Confidence", "Action"] | |
| pdf.set_fill_color(26, 82, 118) | |
| pdf.set_text_color(255, 255, 255) | |
| for h, w in zip(headers, col_w): | |
| pdf.cell(w, 7, h, border=1, fill=True) | |
| pdf.ln() | |
| pdf.set_text_color(0, 0, 0) | |
| pdf.set_font("Helvetica", "", 8) | |
| for i, row in df.iterrows(): | |
| fill = i % 2 == 0 | |
| pdf.set_fill_color(245, 249, 252) if fill else pdf.set_fill_color(255, 255, 255) | |
| for val, w in zip([row["Component"], row["Status"], row["Confidence"], row["Action"]], col_w): | |
| clean_val = strip_md(str(val)) | |
| pdf.cell(w, 6, clean_val, border=1, fill=True) | |
| pdf.ln() | |
| pdf.ln(6) | |
| # Section 5 — Recommendations | |
| section("5. Deployment Recommendations") | |
| gaps = len([r for _, r in df.iterrows() if "GAP" in r["Status"]]) if df is not None else 0 | |
| recs = [ | |
| f"1. Begin with a 2-week technical discovery workshop to validate all requirements.", | |
| f"2. Address {gaps} identified gap(s) before pilot phase to avoid scope creep.", | |
| f"3. Build a proof-of-value prototype in weeks 3-4 to validate architecture choices.", | |
| f"4. Establish daily standup cadence and weekly stakeholder demos from day one.", | |
| f"5. Document all integration points and obtain sign-off before production deployment.", | |
| f"6. Define SLAs, rollback procedures, and monitoring dashboards pre-go-live.", | |
| ] | |
| for rec in recs: | |
| pdf.set_font("Helvetica", "", 10) | |
| pdf.multi_cell(0, 6, rec) | |
| pdf.ln(1) | |
| # Footer | |
| pdf.set_y(-15) | |
| pdf.set_font("Helvetica", "I", 8) | |
| pdf.set_text_color(128, 128, 128) | |
| pdf.cell(0, 10, "ForwardDeployAI — Powered by Hugging Face | github.com/Faraz6180", align="C") | |
| # Save | |
| with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp: | |
| pdf.output(tmp.name) | |
| return tmp.name, "✅ Report generated successfully! Click download to save." | |
| # ───────────────────────────────────────── | |
| # Gradio UI | |
| # ───────────────────────────────────────── | |
| CSS = """ | |
| .gradio-container { font-family: 'Segoe UI', sans-serif; } | |
| .tab-nav button { font-weight: 600; font-size: 14px; } | |
| footer { display: none !important; } | |
| """ | |
| with gr.Blocks( | |
| title="ForwardDeployAI", | |
| theme=gr.themes.Base( | |
| primary_hue="blue", | |
| secondary_hue="indigo", | |
| font=gr.themes.GoogleFont("Inter"), | |
| ), | |
| css=CSS | |
| ) as demo: | |
| gr.HTML(""" | |
| <div style='text-align:center; padding:24px 0 8px 0;'> | |
| <h1 style='font-size:2rem; color:#1A5276; margin:0;'>🏗️ ForwardDeployAI</h1> | |
| <p style='color:#555; margin:6px 0 0 0; font-size:1rem;'> | |
| Enterprise Solution Architecture Assistant — Powered by Hugging Face | |
| </p> | |
| <p style='color:#888; font-size:0.85rem; margin:4px 0 0 0;'> | |
| Requirement Analysis · Solution Architecture · Fit-Gap Analysis · Deployment Reports | |
| </p> | |
| </div> | |
| """) | |
| # ── Shared Inputs ── | |
| with gr.Accordion("📥 Client Brief (used across all tabs)", open=True): | |
| with gr.Row(): | |
| inp_client = gr.Textbox(label="Client Name", placeholder="e.g. Acme Corp", scale=2) | |
| inp_industry = gr.Textbox(label="Industry", placeholder="e.g. Healthcare, FinTech", scale=2) | |
| inp_timeline = gr.Number( label="Timeline (weeks)", value=12, scale=1) | |
| inp_budget = gr.Textbox(label="Budget Range", placeholder="e.g. $100K–$250K", scale=1) | |
| inp_requirements = gr.Textbox( | |
| label="Client Requirements", | |
| placeholder="Describe the business problem and what the client needs...", | |
| lines=5 | |
| ) | |
| with gr.Row(): | |
| inp_existing = gr.Textbox( | |
| label="Existing Systems / Tech Stack", | |
| placeholder="e.g. SAP ERP, on-premise SQL Server, legacy Java monolith", | |
| lines=2, scale=3 | |
| ) | |
| inp_capabilities = gr.Textbox( | |
| label="Available Platform Capabilities", | |
| placeholder="e.g. Authentication, API Layer, Cloud hosting, CI/CD", | |
| lines=2, scale=3 | |
| ) | |
| with gr.Tabs(): | |
| # ── Tab 1 ── | |
| with gr.Tab("📋 Requirement Analyzer"): | |
| gr.Markdown("Classifies business requirements into technical categories using **BART-Large-MNLI** zero-shot classification.") | |
| btn1 = gr.Button("🔍 Analyze Requirements", variant="primary", size="lg") | |
| with gr.Row(): | |
| out1_md = gr.Markdown(label="Analysis") | |
| out1_df = gr.Dataframe(label="Category Scores", wrap=True) | |
| btn1.click( | |
| analyze_requirements, | |
| inputs=[inp_client, inp_industry, inp_requirements, inp_existing], | |
| outputs=[out1_md, out1_df] | |
| ) | |
| # ── Tab 2 ── | |
| with gr.Tab("🏗️ Solution Architect"): | |
| gr.Markdown("Generates a full solution architecture, component breakdown, data flow, and phased delivery plan.") | |
| btn2 = gr.Button("⚙️ Generate Architecture", variant="primary", size="lg") | |
| out2_md = gr.Markdown(label="Architecture") | |
| btn2.click( | |
| generate_architecture, | |
| inputs=[inp_client, inp_requirements, inp_timeline, inp_budget], | |
| outputs=out2_md | |
| ) | |
| # ── Tab 3 ── | |
| with gr.Tab("🔍 Fit-Gap Analyzer"): | |
| gr.Markdown("Evaluates which solution components are required vs available, identifying gaps and optional features.") | |
| btn3 = gr.Button("📊 Run Fit-Gap Analysis", variant="primary", size="lg") | |
| with gr.Row(): | |
| out3_md = gr.Markdown(label="Fit-Gap Report") | |
| out3_df = gr.Dataframe(label="Gap Table", wrap=True) | |
| btn3.click( | |
| run_fitgap, | |
| inputs=[inp_client, inp_requirements, inp_capabilities], | |
| outputs=[out3_md, out3_df] | |
| ) | |
| # ── Tab 4 ── | |
| with gr.Tab("📄 Deployment Report"): | |
| gr.Markdown("Runs all three analyses and compiles a downloadable **PDF deployment readiness report**.") | |
| btn4 = gr.Button("🖨️ Generate PDF Report", variant="primary", size="lg") | |
| out4_status = gr.Markdown() | |
| out4_file = gr.File(label="📥 Download Report", file_types=[".pdf"]) | |
| btn4.click( | |
| generate_report, | |
| inputs=[inp_client, inp_industry, inp_requirements, inp_existing, | |
| inp_capabilities, inp_timeline, inp_budget], | |
| outputs=[out4_file, out4_status] | |
| ) | |
| # ── Tab 5 ── | |
| with gr.Tab("ℹ️ About"): | |
| gr.Markdown(""" | |
| ## About ForwardDeployAI | |
| This tool simulates the core workflow of a **Forward Deployment Engineer** — the bridge between client business requirements and scalable technical solutions. | |
| ### 🤖 Hugging Face Models Used | |
| | Model | Task | | |
| |---|---| | |
| | `facebook/bart-large-mnli` | Zero-shot requirement classification | | |
| | `facebook/bart-large-cnn` | Requirement summarization | | |
| ### 🔧 What It Does | |
| 1. **Requirement Analyzer** — Classifies free-text client requirements into 10 technical architecture categories with confidence scores | |
| 2. **Solution Architect** — Recommends architecture patterns, component stacks, data flows, and phased delivery plans | |
| 3. **Fit-Gap Analyzer** — Evaluates 8 core solution components against available capabilities and flags gaps | |
| 4. **Report Generator** — Produces a branded, multi-section PDF deployment readiness report | |
| ### 👤 Built by | |
| **Faraz Mubeen Haider** — AI Engineer | |
| [github.com/Faraz6180](https://github.com/Faraz6180) · [linkedin.com/in/farazmubeen-ai](https://linkedin.com/in/farazmubeen-ai) | |
| """) | |
| gr.HTML(""" | |
| <div style='text-align:center; padding:16px; color:#aaa; font-size:0.8rem; border-top:1px solid #eee; margin-top:16px;'> | |
| ForwardDeployAI · Powered by 🤗 Hugging Face · Built by Faraz Mubeen Haider | |
| </div> | |
| """) | |
| demo.launch() |