Built a Medical AI Agent in Just 3 Days

Can you really build a fully functioning medical AI agent in just a few days?

That was the question I set out to answer — driven not just by curiosity, but by a real-world problem voiced by someone I trust deeply.

As a software engineer with a foot in medical research, I’ve always been fascinated by healthcare technology. My wife, a practicing doctor, kept bringing up a pain point: while AI tools like ChatGPT are amazing, they often lack medically accurate, evidence-based answers.

That was my spark. I wanted to create something better — an AI assistant that doesn't guess, but knows, based on structured and verified medical data.

Day 1: Blueprinting the Vision & Structuring the Data

The journey started with a bold goal: build an AI assistant that can provide reliable, medically sound answers using only the documents I provide — no hallucinations allowed.

To kick it off, I asked GPT-4 a foundational question:

“How can I build a medical AI agent that only answers based on the specific medical documents I feed it?”

Armed with that prompt, I mapped out the architecture:

• LangChain and LangGraph to define the agent’s logic flow.
• A test case involving financial queries — because if it can tell you the price of Bitcoin, it can answer medication prices too.
• Qdrant for storing PDF-based medical leaflets as searchable vector embeddings.
• Neo4j to model drug-to-drug interaction data using a knowledge graph.
• A Swagger-powered API to experiment with logic flows and tool switching.

Once the framework was clear, it was time to build the knowledge core.

I deployed Qdrant and Neo4j to an Azure virtual machine, then dusted off an old Excel file from my med-research days — full of drug interaction data. I wrote scripts to parse and load it into Neo4j.

Simultaneously, I scraped medical leaflets (RCPs) from the national drug agency's website, built a parser, and stored them in Qdrant for semantic search.

The AI’s brain had its raw material — now it needed a way to think like a doctor.

Day 2: Teaching the AI to Think Like a Doctor

With the data infrastructure ready, I turned to the core intelligence.

Using LangChain, I developed two specialized tools:

• process_medication_query: handles general drug-related questions.
• process_interaction_query: checks for potential drug interactions.

Both were designed to parse full natural-language input, not just keywords — making the interaction feel intuitive and human.

Qdrant integration was smooth. Neo4j, though? Not so much.
Initially, I attempted dynamic Cypher generation using GPT — but the moment the schema shifted, everything broke. Frustrated but motivated, I revisited the design and found GraphCypherQAChain — a game changer. Now I could pass in natural language questions, and the system would automatically query the knowledge graph. No more headaches.

By the end of the day, I had a functioning backend engine that reasoned like a clinician, searched like a librarian, and communicated like a human.

Day 3: Assembling the User Interface and Going Live

Now that the intelligence was working, it needed a face — something users could interact with.

I found an open-source React (Next.js) project under the MIT license. It looked great and used WebSockets for real-time communication. With the help of GPT, I quickly generated the Python backend needed to handle WebSocket-based communication with the AI agent.

To streamline the backend features, I integrated Supabase — which turned out to be a hidden gem. Supabase’s built-in AI agent took care of:

• Authentication
• Chat history storage
• Feedback collection
• Admin tools

I barely touched the Supabase dashboard — and yet everything worked flawlessly.

With the frontend polished and the backend humming, I pushed the code to GitHub, cloned it on the Azure VM, set up NGINX, Certbot, and SSL, and officially launched the agent.

As a bonus, I added new document types — clinical guidelines and operational protocols. The agent parsed and responded to them immediately. That moment? Pure satisfaction.

The Final Result

It’s live, functional, and built in just three focused days.

You can test it here: https://medical-agent.corlab.tech/

Key Takeaways from the Build

• Anyone can build an AI agent today. It’s no longer just about coding skills — it’s about domain expertise and clear thinking.
• AI-generated code is helpful, not perfect. Be ready to debug, but don’t let bugs block your momentum.
• RAG (Retrieval-Augmented Generation) in healthcare is powerful. While the agent still needs clinical validation and fine-tuning, the prototype proves there’s real potential.

Why This Matters for Software Development Teams

This project goes beyond a weekend hackathon — it’s a glimpse into how small teams can rapidly prototype domain-specific AI tools that solve real problems.

In healthcare especially, precision, context, and explainability matter. A general-purpose chatbot won’t cut it when clinicians are making decisions about medications or patient safety. That’s why Retrieval-Augmented Generation (RAG), powered by curated medical documents and structured drug interaction data, becomes a game-changer.

Even more exciting? The same architecture can be adapted to:

• Power internal clinical knowledge assistants
• Automate decision support in hospitals
• Help pharmaceutical teams manage and query protocol documents
• Deliver contextual help inside EHR systems

If you’re a healthtech startup, custom software development company, or enterprise tech leader, this build is proof that:

• AI agents are no longer theoretical.
• You don’t need a team of PhDs to get started.
• What matters more than deep ML expertise is knowing the domain and choosing the right tools.

Rapid experimentation is the new competitive edge — and this project demonstrates how to go from concept to MVP in days, not months.

Lessons Learned from the Hard Parts

While this sounds like a smooth ride, here’s the truth: it wasn’t.

One of the biggest hurdles was generating dynamic Cypher queries for Neo4j. I initially relied on GPT to generate them on the fly. It worked — until it didn’t. Any slight schema update or naming inconsistency would break the logic completely. After two frustrating hours of debugging with no end in sight, I scrapped it. That’s when I found GraphCypherQAChain, which could automatically map natural language questions to Cypher queries. A huge relief.

Another challenge was integrating WebSocket communication in an unfamiliar React template. It looked great on the outside, but required precise real-time syncing with the Python backend. Fortunately, GPT and Supabase helped automate most of the grunt work — though I still needed to manually debug authentication flow and message broadcasting to make everything click.

And then there’s the classic AI pitfall: hallucination. Even with carefully selected documents, I had to test and tweak prompts to make sure the agent didn’t go off-script or fabricate information when uncertain. That fine-tuning still isn’t perfect — but it’s already miles ahead of a vanilla LLM chat.