AWS Builder Center
ADDA-AI

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:
  1. Which capability was selected (Coding, Document, Search or Research)
  1. What work was performed (the steps the system actually ran)
  1. 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

  1. Coding: "Write a Python function to reverse a string." The Coding Agent returns a highlighted  reverse_string  block, clearly marked as a fixed sample.
  1. Search: "What are the latest developments in AI agents?" The Search Agent returns a summary with real source links.
  1. 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.
  1. 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 frontend is deployed on AWS Amplify:  main.dvhyzvzxczywv.amplifyapp.com 
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

  1. Verify Bedrock inference with the configured model and switch Coding from  demo  to  bedrock 
  1. Deploy the API with API Gateway and Lambda via SAM, then point the Amplify frontend at it. The Lambda template sets  DOCUMENT_ENABLED=false  today, because process-local document storage isn't safe across separate Lambda instances.
  1. Add shared durable storage, such as Amazon S3, so documents work in the cloud
  1. 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

  • 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 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article