🚀 Verto: Agentic Deployment Infrastructure

Verto is an automated, agentic pre-deployment safety guardrail for modern engineering teams.

It acts as a native GitHub App that intercepts your Pull Requests and runs a battery of highly specific Check Engines to detect high-risk infrastructure changes (like N+1 queries, dropped databases, or missing environment variables).

But Verto goes further than passive code review. When a vulnerability is found, Verto acts as an Agentic Auto-Fixer—using Llama 3.1 via Groq to completely rewrite the problematic code and seamlessly pushing the optimized fix back to your GitHub Pull Request as a one-click commit suggestion.

🔗 Live Environments

• Frontend Dashboard: https://verto-phi.vercel.app
• GitHub App: Verto Deploy Checker

---

📖 Table of Contents

• Features
• System Architecture
• Getting Started Locally
• Open Source & Community
• License

---

✨ Features

• 🤖 Agentic Auto-Fixer: When Verto catches a performance issue (like an N+1 query), it automatically rewrites the code using eager loading and posts a suggestion directly on the PR. Developers can fix complex infrastructure bugs with a single click.
• Zero-Config Setup: Get up and running in under 2 minutes. Install the Verto GitHub App on your repository, and it automatically starts reviewing pull requests—no YAML configuration or CI changes needed.
• AI-Powered Check Engines:
  • 🧠 Config Archaeology & Graph Memory: Powered by neuro-symbolic graph memory (Cognee), Verto audits environment variables against historical Git commits, PR discussions, and past production outages, generating instant Danger Scores (0–100) and safe operating boundaries. Supports both Open Source local embedded inference and Cognee Cloud API.
  • 🚨 Self-Improving Negative Feedback Loop: When a production outage occurs, submitting an incident report via /api/incidents feeds negative feedback directly back into Cognee's graph memory (await cognee.remember(...)), permanently increasing the danger score for that variable so no engineer repeats the mistake.
  • ⚡ Performance Checks: Catches N+1 query patterns and inefficient loops that could silently degrade your application's performance.
  • 🔐 Environment Variable Validator: Pulls live environment variables directly from the Vercel API and cross-references them against the PR diff to ensure no secrets are leaked or missing.
  • 💾 Database Migration Classifier: Scans the git diff for dangerous database operations (e.g., DROP TABLE, DELETE, changing primary keys) in migration files.
  • 🛠️ Custom Rule Builder: Define your own regex-based deployment rules (e.g., blocking console.log or AWS keys). Verto scans every PR for your custom patterns.
• Premium Light-Mode Dashboard: A beautifully designed, Vercel-inspired Next.js dashboard to visualize deployment safety, manage custom rules, and configure cloud integrations.
• Enterprise-Grade Security: The dashboard and the FastAPI backend are completely secured using Clerk JWT Authentication. Only authorized users can access the API or view the deployment history.
• ChatOps Notifications: Sends intelligent, LLM-generated summaries of the PR's safety directly to your Slack and Discord channels.

---

🏗️ System Architecture

Verto is designed as an asynchronous, event-driven platform. When a developer opens a Pull Request, Verto orchestrates a complex pipeline of code analysis, external API syncing, Agentic auto-fixing, and ChatOps notifications in seconds.

sequenceDiagram
    participant Dev as Developer
    participant GH as GitHub
    participant Verto as FastAPI Backend
    participant Engines as Check Engines
    participant LLM as Groq (LLaMA 3)
    participant DB as Neon DB (Postgres)

    Dev->>GH: Opens Pull Request
    GH->>Verto: Webhook (pull_request opened)
    Verto->>GH: Mark Commit Status as "Pending"
    
    par Run Check Engines
        Verto->>Engines: Dispatch PR Diff
        Engines->>DB: Fetch Active Custom Rules
        Engines-->>Verto: Return pass/fail results
    end
    
    opt If Issue is Auto-Fixable (e.g., N+1 Query)
        Verto->>GH: Download Raw Source File
        Verto->>LLM: Prompt Agent to rewrite code
        LLM-->>Verto: Return optimized code snippet
        Verto->>GH: Post Inline PR Suggestion
    end

    Verto->>DB: Persist Check Results
    Verto->>LLM: Send results for overall AI Summarization
    LLM-->>Verto: Return Confidence Score & Summary
    
    Verto->>GH: Post PR Comment & Update Commit Status

Loading

Component Breakdown

1. Frontend (Dashboard)

   • Built with Next.js App Router and Tailwind CSS.
   • Secured by Clerk authentication.
   • Provides a real-time interface to view deployment history and manage Custom Rules.

2. Backend (API & Webhooks)

   • Built with FastAPI for high-performance, asynchronous webhook processing.
   • Secured via a custom auth.py dependency that verifies Clerk JWTs natively.
   • Listens to GitHub App webhooks and verifies cryptographic signatures.

3. Check Engines & Agentic Workflows

   • A modular architecture (checks/base.py) allowing developers to plug in new engines.
   • The ConfigArchaeologyCheck engine queries Cognee neuro-symbolic graph memory to audit environment variables against historical commits, PR discussions, and production outages—calculating Danger Scores and Safe Operating Boundaries.
   • The PerformanceCheck engine identifies specific lines of code that need fixing and triggers the agentic_fix_code workflow to automatically patch the repository.

4. AI, Graph Memory & Persistence

   • Cognee 1.2.2 provides dual-mode vector and relational graph memory (Open Source local embedded inference & Cognee Cloud API) for deep config provenance tracking and self-improving negative feedback loops (/api/incidents).
   • Groq API (LLaMA 3.3 / 3.1) powers the code rewriting engine, Cognee graph reasoning, and human-readable summary generation.
   • Neon Serverless Postgres stores all historical check data, PR metadata, and team configurations.

---

🚀 Getting Started Locally

We've made it as simple as possible to run Verto locally.

Prerequisites

• Python 3.10+
• Node.js 18+
• PostgreSQL database (Neon recommended)
• GitHub App credentials
• Groq API Key
• Clerk API Keys (CLERK_JWKS_URL)

Backend Setup

cd backend
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

# Set up your environment variables
cp .env.example .env

# Run database migrations
alembic upgrade head

# Start the server
uvicorn main:app --reload

Frontend Setup

cd dashboard
npm install

# Set up Clerk and API environment variables
cp .env.example .env.local

# Start the dashboard
npm run dev

---

🤝 Open Source & Community

Verto is an open-source project and we actively welcome contributions from the community! Whether you are fixing a bug, adding a new Check Engine, or improving our documentation, your help is appreciated.

Please see our Contributing Guidelines for details on how to set up your environment, our branching strategy, and how to submit a Pull Request.

By participating in this project, you agree to abide by our Code of Conduct.

---

⚖️ License

This project is licensed under the MIT License. See the LICENSE file for details.