While the initial version of the Agentic Authoring Assistant (AAA) successfully automated metadata generation through modular agents, it lacked a robust deployment pipeline for real-world usability.
This phase focused on transforming the research prototype into a production-ready web application — reliable, secure, and scalable for public interaction.
The upgraded system addresses two main problems:
Accessibility: Bringing the multi-agent backend to a usable web interface.
Reliability: Ensuring safe, monitored, and fault-tolerant execution of agent workflows.
The production version of AAA integrates FastAPI, LangGraph, and OpenRouter LLMs into a modular backend pipeline.
Users submit text or abstracts via a web UI, which triggers a sequence of autonomous agents that process, refine, and enrich metadata.
| Component | Technology | Role |
|---|---|---|
| Frontend | HTML + JS (templated) | Simple text input and formatted result display |
| Backend Framework | FastAPI | Handles API routing, validation, and async agent execution |
| Orchestration Engine | LangGraph | Connects Metadata, Refiner, and Reference agents |
| Database | Qdrant (optional) | Stores and indexes metadata embeddings |
| LLM Provider | OpenRouter API | Powers metadata generation and refinement |
| Web Search | Tavily API | Supplies live references and supporting material |
User sends a project description via a POST request (e.g., /generate_metadata).
The Metadata Agent creates raw titles, tags, and a summary.
The Refiner Agent enhances readability and structure.
The Reference Agent pulls in web references using Tavily.
The response is aggregated into a structured output with:
Titles
Summary
Tags
References (with real clickable URLs)
Moving from local testing to cloud deployment required several key engineering improvements:
Each agent’s function (metadata, refiner, reference) was exposed through async API endpoints, allowing clean orchestration and easy external access.
Used async/await patterns within FastAPI routes to handle multiple generation requests efficiently — crucial when calling LLMs and web APIs concurrently.
Implemented Pydantic models to validate input fields, ensuring only valid project data reaches the agent pipeline.
Added prompt-safety filters and a toxic language guard to prevent unsafe or adversarial input from triggering unwanted LLM behavior.
Pushed directly to Render using GitHub auto-deploys. Render manages build, start, and scaling automatically, making it ideal for small research-grade deployments.
The interface is simple and functional:
An input field for project description.
A “Generate Metadata” button.
A results section showing titles, summary, tags, and reference links.
While the focus remained backend-centric, the output formatting was refined to be human-readable and Markdown-compatible for easy export into documentation systems.
(You may attach screenshots or short demo video here.)
Testing Strategy:
Unit Tests: Validated each agent’s function (metadata, refiner, reference).
Integration Tests: Ensured the full flow from FastAPI → LangGraph → Output worked smoothly.
API Tests: Used pytest and httpx to test endpoints’ response times and schema consistency.
Adversarial Testing: Injected malformed or toxic input to confirm guardrails caught unsafe behavior.
Guardrails applied at both the input and output stages.
API key environment isolation in .env to avoid accidental leaks.
Input sanitization before passing user text to LLMs.
Automatic retries for network/API errors.
Graceful fallbacks if Tavily or OpenRouter fail.
User-friendly error messages for failed generations.
Console and file-based logs for all API requests and model responses.
Render’s built-in logs used for deployment health checks.
Future scope: integration with Prometheus for metrics visualization.
Deployment followed a lightweight CI/CD approach using Render.
Steps:
Commit changes to GitHub repository.
Render auto-builds and redeploys FastAPI app.
Environment variables (OPENROUTER_API_KEY, TAVILY_API_KEY, etc.) configured in Render Dashboard.
App served via public endpoint
This phase focused on bringing the Agentic Authoring Assistant to life online — turning a structured local prototype into a publicly available, production-grade application.
By integrating FastAPI for orchestration, implementing safety guardrails, and deploying seamlessly on Render, the system now offers real-time autonomous metadata generation with stable performance and minimal maintenance overhead.
It demonstrates how accessible AI deployment can bridge research systems and real-world tools — empowering developers and organizations to utilize agentic automation without deep ops infrastructure.
🎥 Watch the Demo Video: Demo_Video
🌐 Live API: Link