Abstract

ChemIntelliGraph introduces an Agentic Retrieval-Augmented Generation (RAG) framework for Chemistry that integrates multiple specialized AI agents—retrieval, reasoning, synthesis, and validation—coordinated using LangGraph.
The system builds on the Chemixtry RAG Lab concept but evolves it into a multi-agent cognitive architecture, enabling autonomous retrieval, fact-checking, and scientific reasoning using both structured and unstructured chemical data.

Introduction

ChemIntelliGraph represents a next-generation evolution of the Chemistry RAG Lab — integrating agentic intelligence and graph-based orchestration to simulate multi-step scientific reasoning.
The system uses LangGraph to coordinate autonomous retrieval, reaction reasoning, validation, and visualization agents.
By fusing vector-based semantic retrieval with dynamic inter-agent communication, the framework provides an explainable and modular foundation for AI-augmented chemical experimentation and educational simulations.

Methodology

1️⃣ System Architecture
ChemIntelliGraph is composed of four main agents, each with a specialized role coordinated through LangGraph:

The LangGraph controller ensures stateful, explainable agent coordination — allowing complex tasks (e.g., reaction prediction + context explanation) to unfold as a conversation between agents.

2️⃣ Knowledge Base
ChemIntelliGraph uses the same verified .txt data sources from Chemixtry Lab, expanded with relation triples for graph construction:

• reactions_knowledge.txt
• oxidation_reduction.txt
• bio_reactions.txt
• compound_properties.txt
  Each document is preprocessed, chunked, and embedded using SentenceTransformer (all-MiniLM-L6-v2).
  Vector embeddings are stored in ChromaDB and indexed for efficient cosine-similarity retrieval.

3️⃣ Agentic RAG Workflow

• User Query → Retriever Agent
  Fetches top-matched text segments and relevant knowledge graph nodes.
• Retriever → Reasoning Agent
  Injects context + question into a structured RAG prompt template.
• Reasoning Agent → Validation Agent
  Checks chemical plausibility and ensures retrieval integrity.
• Validated Output → Knowledge Graph Agent
  Updates node connections dynamically based on new findings.

4️⃣ Prompt Engineering

Strict Mode

Factual mode – Only uses retrieved knowledge + graph data.
If information missing → respond with “No known reaction found.”

Creative Mode

Allows generative reasoning, e.g., conceptual analogies or reaction predictions, explicitly labeling inferred reasoning.
Technical Implementation → achieved via prompt templates and agent routing using LangGraph/LangChain.
if mode == "strict":
agent = StrictChemAgent(llm=groq_model, retriever=db)
else:
agent = CreativeChemAgent(llm=openai_model, retriever=db)

Impact: Offers dual interpretability — both correctness (for researchers) and creativity (for educators or students).
5️⃣ Agent Coordination (LangGraph Flow)
The multi-agent orchestration is built as a LangGraph graph flow, connecting each agent sequentially:

User → Retriever → Reasoner → Validator → Graph Agent → Response

Each node in the LangGraph represents a thinking step, ensuring:

• Transparent reasoning trace
• Reproducible decisions
• Easy addition of new domain agents (e.g., ToxicityCheckerAgent)
  

Reasoning Experiments

Dual Reasoning Modes (Strict vs Creative)

Dual Reasoning Framework

ChemIntelliGraph introduces a bifurcated reasoning system with two operational modes:

Strict Mode — A deterministic reasoning path.

• Uses retrieval-only approach from vectorized knowledge base.
• Enforces factual correctness.
• Rejects speculative or unverified chemical outcomes.
• Implemented via a system-level prompt constraint that filters out unsupported generation.
  
  

Creative Mode — A guided inferential reasoning path.

• Blends retrieval context with general LLM world knowledge.
• Encourages exploration of reaction mechanisms and hypothetical extensions.
• Explicitly labels inferred segments for transparency (“Based on known chemistry…”).
  
  Together, these modes balance accuracy and creativity, enabling both structured education and innovative exploration.

Safety & Validation Layer

Every user query passes through a Safety Checker pipeline that:

• Detects unsafe, explosive, or illegal reaction simulations.
• Blocks manipulative, toxic, or unethical queries.
• Applies regular expression filters and semantic classification for lab safety.
• Returns neutral educational responses when unsafe queries are detected.
  

Memory & Context Persistence

ChemIntelliGraph integrates a short-term conversational memory that allows continuity across turns:

• Tracks the current reaction chain, reagents, and intermediate compounds.
• Enables contextual follow-ups (“Now add NaOH — what happens?”).
• Stores user experiment history for multi-step reasoning and revision.
  This design transforms static question answering into interactive multi-turn experimentation, simulating the iterative reasoning process of real chemists.
  

Technical Highlights

• 🔬 Dual-mode reasoning: Strict (factual) and Creative (inferred)
• 🧩 Context-aware RAG pipeline with semantic embeddings
• 🔐 Safety Checker for lab-safe reasoning
• 💡 Memory-enabled conversational continuity
• ⚙️ Modular prompt templates for dynamic reasoning control
• 🧩Vector Database: ChromaDB with SentenceTransformer embeddings
• 🔬 LLM Backends: Groq (for deterministic output), Gemini/OpenAI (for creative output)
• ⚙️ LangGraph Integration: For multi-agent orchestration and state management
• 🔐API Integration: SerpAPI for real-time chemistry facts or recent research
• 💡Modular Architecture: RAG + Multi-agent + Dual Mode pipeline

Setup & Usage

Step 1. Clone and Setup

git clone https://github.com/Blessy456b/chem_intelligraph.git
cd chem_intelligraph/src
python3 -m venv rag_lab_env1
source rag_lab_env1/bin/activate
pip install -r requirements.txt

Export MCP_SECRET before starting the backend

When you start your backend server, you’ll want this environment variable available to any process (especially the Streamlit app).
This ensures the app can verify requests coming from your MCP server.
Run:

export MCP_SECRET="<YOUR_RANDOM_SECRET>"

Step 2. Environment Configuration

Create .env:

GROQ_API_KEY=your_groq_key_here
SERPAPI_KEY=your_serpapi_key_here
MCP_SECRET=super_secret_mcp_key
MCP_BASE=http://127.0.0.1:8080/tool

Run the MCP (FastAPI or Uvicorn) server

If your project has a FastAPI server (say in mcp_server.py):

uvicorn mcp_server:app --host 127.0.0.1 --port 8080 --reload

Step 3. Run App

Option 1 – Streamlit Interface

streamlit run app_chemintelligraph.py

Streamlit Interface (Recommended)

Once launched, open the local URL displayed in your terminal (e.g.,
http://localhost:8501 ) to interact with the assistant.
You’ll see:

• Input Textbox for entering reactants
• Visual test tubes

🧾 Results

• Reduced hallucination rate via structured multi-agent verification.

• Dynamic graph visualization of agentic relationships.

• InMemory results cached

• Better factual consistency than single-agent RAG system

Future Work

• This is Version 1 , next version will follow with graphics for testube and multimodal input
• Cross-lingual RAG for Indian languages.
• Autonomous hypothesis testing using simulation agents.

Conclusion

ChemIntelliGraph advances explainable scientific reasoning by embedding agentic intelligence within the RAG framework.