
ADDA-AI
ADDA AI is a multi-agent workspace that routes Coding, Document, Search and Research tasks and shows the capability used, the steps run and the evidence behind every answer. Built with LangGraph, FastAPI, Next.js and AWS Amplify.
ADDA AI: One Workspace for Code, Documents and Search, with the Evidence Shown
Built by Tech-Team for the hackathon with Next.js, FastAPI, LangGraph and AWS (Amplify deployed; Bedrock, Lambda and API Gateway next)
The problem
We all jump between a code assistant, a PDF reader and a search engine. The bigger issue is that we lose track of where an answer came from. Was it generated by a model, quoted from a document, or pulled from a web page?
ADDA AI puts these tasks in one workspace and makes three things visible for every answer:
- Which capability was selected (Coding, Document, Search or Research)
- What work was performed (the steps the system actually ran)
- What evidence supports the result (page citations and real source URLs)
What we built
ADDA AI is a multi-agent workspace with a deterministic router. You type a task, and the router picks one of four specialists:
Agent | What it does | Provider label in the UI |
|---|---|---|
Coding | Routes to a code-generation path (Amazon Bedrock Converse integration, or a labelled fixture in demo mode) | demo / bedrock |
Document | Upload a PDF or TXT, ask a question, get page-cited excerpts | extractive |
Search | Live web search with a summary and real https:// source links | tavily |
Research | Plans two evidence checks, collects excerpts and assembles a cited brief | extractive |
Every response footer states which provider actually produced it, so a fixture never looks like a model answer.
Architecture
The stack has two runtimes, a web app and an API. The agents are modules inside the API rather than separate services.
- Frontend: Next.js (static export) hosted on AWS Amplify, with task history, upload, citation cards, code highlighting and copy, and an activity panel beside the result
- Backend: FastAPI with LangGraph orchestrating the workflow
- Router: deterministic, so the same prompt always takes the same path
- Document retrieval: bounded local keyword retrieval over extracted PDF/TXT text, with page numbers preserved
- Search: Tavily adapter, capped at five basic results plus a provider summary
- Coding: Amazon Bedrock Converse integration, with a labelled demo fixture as the default
Why LangGraph
LangGraph makes the workflow explicit. Routing, planning, collection and reporting are separate executable steps, and the UI shows the ones that completed. For the Research agent the graph is:
Router → Research plan → Collect evidence → Evidence brief
This is what lets us tell retrieved evidence, a fixed fixture and a real model response apart.
The demo flow
- Coding: "Write a Python function to reverse a string." The Coding Agent returns a highlighted
reverse_stringblock, clearly marked as a fixed sample.
- Search: "What are the latest developments in AI agents?" The Search Agent returns a summary with real source links.
- Documents: We attach a fictional three-page project PDF and ask, "What is the approved budget?" The Document Agent returns the excerpt containing INR 180,000, cited to page 2.
- Research: "Research this document: summarize the evidence and identify the risks and limitations." The Research Agent runs a four-step workflow and returns a page-cited evidence brief.
The document and research flows work without any provider key, because they use real source text and keyword retrieval.
Live deployment
The backend API is not deployed to AWS yet, so the full agent workflows currently run against a local API. The hosted frontend shows the interface, and its status badge will read offline until an API is connected.
Being honest about what's verified
We deliberately kept the labels strict. This is the state of the project as of today:
Verified
- Frontend deployed on AWS Amplify
- Locally: Coding fixture, document Q&A with page citations, and the Research workflow
- Locally: live Search with a Tavily key configured
- Backend test suite (71 tests passing, external calls mocked), frontend typecheck and production build
- Desktop and mobile layout checks
Prepared but not verified
- Live Amazon Bedrock inference. The Converse integration is written, but we have not confirmed a real invocation, so we make no claim that Coding is model-generated.
- API deployment. SAM (API Gateway + Lambda) configuration exists, but the API has not been deployed.
Not implemented
- Embeddings, a vector database, OCR, or LLM synthesis. The Research brief is extractive, not model-generated analysis or independent fact-checking.
- Real authentication. The login and register pages are previews and send no credentials.
- Durable storage. Uploaded documents live in one API process for up to an hour and disappear on restart.
Live provider errors never silently fall back to the demo fixture, so a failure shows up as a failure.
Security choices
- Secrets stay in backend environment variables only, never in public frontend variables
- Uploads are limited to PDF or UTF-8 TXT, 5 MB and 30 pages, with bounded text extraction
- Each uploaded document has its own secret token for retrieval and deletion
- Generated code is never executed, and uploaded documents and web sources are treated as untrusted data
Next steps on AWS
- Verify Bedrock inference with the configured model and switch Coding from
demotobedrock
- Deploy the API with API Gateway and Lambda via SAM, then point the Amplify frontend at it. The Lambda template sets
DOCUMENT_ENABLED=falsetoday, because process-local document storage isn't safe across separate Lambda instances.
- Add shared durable storage, such as Amazon S3, so documents work in the cloud
- Add semantic retrieval with embeddings, if time allows
What we learned
- Making provenance a first-class part of the UI changes how much you trust the output.
- Explicit graph steps make an "agent" easy to inspect, test and explain.
- Deterministic routing and bounded retrieval made the system testable without any external keys.
- Being strict about "implemented vs. stubbed vs. unverified" saved us from overclaiming under demo pressure.
Try it
- Live frontend: main.dvhyzvzxczywv.amplifyapp.com
- Repository: github.com/pesanish5-bot/ADDA-AI
- Team: Tech-Team
To run the full stack locally, create a Python venv, install
services/api/requirements-dev.txt , run npm ci in apps/web , start the API with scripts/start_api.py , and start the frontend on port 3000. The README has the full steps.ADDA AI is a hackathon MVP. It shows a working, inspectable document workflow and an extensible graph architecture, with clear boundaries around what has actually been verified.
Tags:
#AWS #AWSAmplify #AmazonBedrock #LangGraph #FastAPI #Nextjs #AIAgents #Hackathon Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article