MedGraph-AI

中文说明

MedGraph-AI is a multi-agent medical assistant built with LangGraph and LangChain. It unifies medical knowledge question answering, time-sensitive web retrieval, and medical image analysis under one routed workflow, then adds human review for high-risk outputs.

Overview

MedGraph-AI focuses on three connected medical workflows:

• Multi-agent medical Q&A routed by LangGraph.
• Medical-domain RAG powered by LangChain, Qdrant, and local embeddings.
• Medical image analysis pipelines with reviewer-in-the-loop handling.

The system is designed as an engineering-oriented project rather than a single demo script. FastAPI and Chainlit provide unified chat, upload, and review entrypoints. SQLite persists chat history and graph checkpoints to support multi-turn conversations, recovery, and review continuity.

Architecture

1. Unified Task Routing

LangGraph acts as the workflow backbone. A supervisor decides whether an incoming request should go to:

• a general medical conversation flow,
• the RAG pipeline,
• the web search flow for time-sensitive information,
• or an image-analysis flow followed by human review.

This keeps routing explicit, makes state transitions traceable, and keeps outputs easier to control in higher-risk medical scenarios.

2. Medical RAG and Web Retrieval

The retrieval layer combines LangChain components with Qdrant-based storage to build a medical-domain RAG workflow. The current implementation includes:

• document parsing and content preparation,
• local embedding generation,
• vector retrieval and reranking,
• source-aware answer generation,
• and Tavily-backed web search for recent external information.

This lets the project answer knowledge-base questions while still supplementing with timely web results when needed.

3. Medical Image Analysis with Human Review

Image-analysis capabilities are wired into the same multi-agent workflow. The repository includes processing paths for:

• chest X-ray classification,
• skin lesion segmentation,
• brain MRI tumor-oriented screening.

For high-risk outputs, the system routes results into a reviewer flow instead of returning them directly. This makes human intervention and review tracking first-class parts of the application rather than an afterthought.

4. Application Layer and Persistence

FastAPI and Chainlit are split by responsibility:

• FastAPI exposes API endpoints, upload handling, and service orchestration.
• Chainlit provides the interactive review and conversation interface.
• SQLite persists chat threads and LangGraph checkpoint state.

This layered structure helps with maintainability, restart recovery, and operational clarity.

Tech Stack

Primary stack:

• LangGraph
• LangChain
• FastAPI
• Chainlit
• Qdrant
• Ollama
• SQLite
• Tavily

Supporting components:

• Docling for document parsing
• PyTorch-based medical vision models
• Hugging Face reranker models
• ElevenLabs speech endpoints

Core Workflows

Medical Question Answering

• User sends a medical question.
• Supervisor routes it to conversation, RAG, or web search.
• Result is returned with agent output metadata and optional references.

Time-Sensitive Retrieval

• Web search is used when up-to-date information is needed.
• Tavily supplements local knowledge with recent external content.
• The final response stays within the same LangGraph-orchestrated pipeline.

Medical Image Review

• User uploads an image with optional context.
• The image is classified into the correct analysis route.
• Model output is sent into the review flow before final response delivery.

Project Structure

.
|-- agents/                   # Multi-agent routing, RAG, web search, image analysis
|-- assets/                   # Flowchart
|-- data/
|   |-- raw/                  # Source documents kept for ingestion
|   `-- raw_extras/           # Additional source materials
|-- docs/
|   `-- README.zh-CN.md       # Public Chinese project description
|-- sample_images/            # Example inputs for image workflows
|-- templates/                # Legacy web template assets
|-- tests/                    # Targeted tests
|-- app.py                    # FastAPI entrypoint
|-- chainlit_app.py           # Chainlit app integration
|-- config.py                 # Central configuration
`-- ingest_rag_data.py        # RAG ingestion utility

Quick Start

1. Clone the Repository

git clone <your-github-repository-url>
cd MedGraph-AI

2. Configure Environment Variables

Use the provided template:

cp .env.example .env

Then update the keys and local service endpoints in .env.

3. Install Dependencies

Recommended with uv:

uv sync

4. Run the App

uv run python app.py

The root path redirects to Chainlit. By default the app is available at:

http://localhost:8000

5. Ingest Medical Documents

uv run python ingest_rag_data.py --dir ./data/raw

Repository Notes

• This project is an engineering portfolio project and research-oriented prototype, not a medical device.
• High-risk image outputs should always go through reviewer validation.
• Large local runtime artifacts, vector stores, checkpoint data, and uploads are intentionally excluded from version control.

Visual Reference

License

This project is licensed under the Apache-2.0 License. See LICENSE.