Projects using Python in DadriProjects using Python in DadriMy submission for replitbuildathon. Features an AI agent that answers inbound leads in seconds, qualifies them against your rules, and books the appointment — rebrandable for a new client in about a minute. Most small businesses lose leads to silence. Someone lands on the site at 9pm, fills nothing in, and leaves. Frontdesk is the agent that catches them. It greets the visitor, works through the qualifying questions you defined, scores what it hears out of 100, books the appointment, and hands the team a lead with the transcript and a follow-up email already drafted. The reason it's a template and not a product: it's built to be rebranded.
Set a logo and two colours in Brand Studio and the entire app, the chat widget, and the design system documentation retint together, because they all read the same tokens. Agencies fork it once per client. Applying a preset doesn't recolour the same install: it opens a different one, with its own agency name, business name and greeting. Checkout the app here: https://frontdeskzip--SuyashDubey3.replit.app That makes total sense. A lot of portfolio platforms like Contra don't support LaTeX rendering, so those equations just end up looking like broken code.
Here is the revised version with the math translated into clean, readable plain text so it formats perfectly on the site.
AuraOps: The Autonomous Unified Release Authority 🚀🧠
Moving AI from "Assisting Developers" to "Making Production Decisions"
Modern CI/CD pipelines are reactive. They lint, test, and warn—but the final decision still depends on a human. As DevOps complexity grows with security risks, compliance requirements, and sustainability concerns, developers are overwhelmed.
We asked a simple question: What if the pipeline itself could decide whether code is safe to ship? That idea led to AuraOps—a multi-agent AI system integrated directly into GitLab Merge Requests that doesn’t just analyze code, but actively fixes it, verifies it, and makes the final release decision.
💡 How It Works: The Autonomous Pipeline
AuraOps intercepts GitLab webhooks when a Merge Request is opened, extracts the code diff, and triggers a 3-phase autonomous pipeline powered by specialized AI agents.
The Execution Flow:
Phase 1 (Parallel): Security & Sustainability Analysis
Phase 2 (Sequential): Validation & Risk Decision
Phase 3 (Parallel): Compliance Checks & Deployment
🤖 The Multi-Agent AI System
AuraOps orchestrates several distinct agents to handle the entire lifecycle:
SecurityAgent: Detects vulnerabilities (SQLi, XSS, secrets), auto-remediates them by writing and committing patches, and re-validates its own fixes.
GreenOpsAgent: Optimizes infrastructure using real-time carbon data and suggests lower-emission deployment regions.
ValidationAgent: Runs the GitLab CI/CD pipeline to ensure AI-generated fixes didn’t break functionality, with graceful fallbacks if CI is down.
ComplianceAgent: Audits code and deployment against SOC2, GDPR, and HIPAA requirements.
DeployAgent: Builds and deploys the application to Google Cloud Run, selecting the greenest, most optimal region.
RiskEngine (The Brain): The decision-making core that aggregates all signals into a single release scorecard and outputs a definitive APPROVE or BLOCK.
🧮 The RiskEngine Decision Model
To confidently block or approve a release without human input, we engineered a weighted decision model to generate a final confidence score.
The core confidence score combines three key weighted metrics:
Security Score * Eco (Sustainability) Score * Validation Result The final AI decision function evaluates this combined score against a strict threshold. For example, if the total confidence score is 75% or higher, the release is securely shipped and marked as APPROVE. If it falls below that mark, the system automatically outputs a BLOCK decision to prevent risky deployments.
🧗♂️ Engineering Challenges
Reliable Auto-Remediation: Detecting issues is easy; safely fixing them is not. We implemented multi-pass revalidation (up to 3 cycles) and auto-commits directly to GitLab.
Failure Resilience: Real-world systems fail. We built AuraOps with graceful degradation—handling CI failures by safely skipping them, retrying API rate limits with exponential backoff, and bypassing missing configs without crashing.
Sustainability as a Metric: Mapping cloud infrastructure to real-time carbon intensity APIs to quantify exact CO₂ savings.
🚀 The Final Output: The Release Scorecard
Instead of overwhelming the developer with logs, AuraOps outputs a clean, aggregated scorecard directly in the MR containing:
Security score & vulnerabilities auto-fixed
Sustainability index & CO₂ emissions avoided
Time saved via automation
Final AI Decision + Confidence Percentage
💻 Built With
AI Models: Gemini 2.5 Flash | Gemini 3.5 Pro | Claude 3.5 Sonnet
Backend & Orchestration: Python | FastAPI | Uvicorn | Node.js | TypeScript
Frontend & 3D Vis: React | Three.js (React Three Fiber) | CSS
DevOps & Cloud: Docker | GitLab API & Webhooks | GitLab CI | Google Cloud Build | Google Cloud Run
Try AuraOps : https://auraops-735853806237.europe-north1.run.app/dashboard
Hit a classic Django trap this week and figured it's worth sharing since so many people are running into it now.
I was adding an LLM feature to a Django app. The AI call takes a few seconds, so naturally I made the view async so it doesn't block a worker while waiting. Wrote the async view, called the ORM like I always do, and boom:
SynchronousOnlyOperation: You cannot call this from an async context.
Turns out Django's ORM can't just be called normally inside async code. The classic sync API isn't safe in an event loop, so Django protects it and throws this error instead.
The fix is simpler than most people think. Since Django 4.1 the ORM has async versions of everything, same names with an "a" prefix. So objects.get() becomes await objects.aget(), create() becomes acreate(), save() becomes asave(). For loops over querysets, async for works directly. And for old sync code or third party libraries you can't change, wrap them with sync_to_async().
Why this matters right now: everyone is bolting AI features onto Django apps, and LLM calls are exactly the slow I/O that async is made for. Which means a lot of devs who never touched async Django are suddenly hitting this error for the first time.
One honest caveat: transactions still don't fully work in async mode, so if you need atomic blocks, keep that path sync and wrap it.
Anyone else made the jump to async views yet, or still happily on WSGI? Problem:
Many organizations still process invoices manually by reading PDF documents and entering key details (invoice number, vendor, amount, etc.) into systems. This process is slow, error-prone, and difficult to scale, and it also makes it harder to detect duplicate invoices or incorrect totals.
Solution:
This project builds an automated invoice processing pipeline that converts uploaded invoice PDFs into structured data. It uses OCR to extract text, LLMs to identify invoice fields, validation checks to ensure correctness, and Kafka-based event streaming to manage the processing pipeline. The extracted data is stored in PostgreSQL and visualized through a dashboard, enabling faster, scalable, and more reliable invoice processing. 
