An enterprise-grade, stateful AI agent system demonstrating advanced LangGraph workflows with tool integration, real-time web search, and automated AI news aggregation.
🚀 Quick Start • 📖 Documentation • 🎯 Features • 📊 Demo
- 🎯 Problem Statement
- 💡 Solution Approach
- 🏗️ Architecture & System Design
- ✨ Key Features
- 🛠️ Tech Stack
- 📁 Project Structure
- 🚀 Quick Start
- 📊 Live Demo & Screenshots
- 🔄 Use Cases Deep Dive
- 📈 AI News Sample Outputs
- 🧠 Implementation Details
- 🔮 Future Roadmap
- 🤝 Contributing
- 📄 License
- 👨💻 Author
In today's rapidly evolving AI landscape, organizations face critical challenges when building conversational AI systems:
| Problem | Impact |
|---|---|
| Stateless Conversations | Traditional chatbots lose context between interactions, leading to fragmented user experiences |
| Limited Tool Integration | Most AI systems cannot dynamically interact with external APIs and real-time data sources |
| Monolithic Architecture | Single-purpose bots lack flexibility and are difficult to scale or modify |
| Information Overload | Keeping up with AI industry developments requires constant manual effort |
| Production Readiness | Transitioning from prototype to production-grade systems is complex |
❌ Customer asks follow-up question → Bot has no memory of previous context
❌ User needs real-time information → Bot provides outdated static responses
❌ Business wants new feature → Entire system needs rebuilding
❌ Team needs AI news digest → Manual curation takes hours daily
This project implements a graph-based, stateful AI agent architecture using LangGraph that addresses all the above challenges through:
┌─────────────────────────────────────────────────────────────────────────┐
│ 🎯 AGENTIC AI SOLUTION FRAMEWORK │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
│ │ STATE │ │ GRAPH │ │ TOOLS │ │
│ │ MANAGEMENT │───▶│ BUILDER │───▶│ INTEGRATION │ │
│ │ │ │ │ │ │ │
│ │ • Messages │ │ • Nodes │ │ • Tavily Search │ │
│ │ • Context │ │ • Edges │ │ • Web Scraping │ │
│ │ • History │ │ • Conditions│ │ • News Aggregation │ │
│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │
│ │ │ │ │
│ └──────────────────┼───────────────────────┘ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ UNIFIED OUTPUT │ │
│ │ • Chat UI │ │
│ │ • Markdown │ │
│ │ • Reports │ │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
| Principle | Implementation |
|---|---|
| 🔄 Stateful Conversations | LangGraph's StateGraph with message accumulation using add_messages reducer |
| 🔧 Modular Architecture | Plug-and-play nodes enabling easy feature additions |
| 🌐 Real-time Data Access | Tavily API integration for live web search capabilities |
| 📊 Automated Intelligence | Self-running news aggregation with LLM-powered summarization |
| 🎨 User-Centric Design | Streamlit-based intuitive interface with configuration-driven customization |
┌─────────────────────────────────────┐
│ STREAMLIT UI │
│ ┌─────────────────────────────┐ │
│ │ • LLM Selection │ │
│ │ • Use Case Selection │ │
│ │ • API Key Management │ │
│ │ • Chat Interface │ │
│ └─────────────────────────────┘ │
└──────────────┬──────────────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────────────────────┐
│ MAIN ORCHESTRATOR │
│ (main.py) │
│ ┌────────────────┐ ┌────────────────┐ ┌────────────────────────────────────┐ │
│ │ UI Loader │───▶│ LLM Config │───▶│ Graph Builder │ │
│ │ │ │ (Groq) │ │ │ │
│ │ • Load Config │ │ │ │ ┌────────────────────────────┐ │ │
│ │ • Get Inputs │ │ • API Key │ │ │ USE CASE ROUTER │ │ │
│ │ • Validate │ │ • Model Select │ │ │ │ │ │
│ └────────────────┘ └────────────────┘ │ │ ┌──────┐ ┌──────┐ ┌────┐ │ │ │
│ │ │ │Basic │ │Tool │ │News│ │ │ │
│ │ │ │Chat │ │Chat │ │Bot │ │ │ │
│ │ │ └──────┘ └──────┘ └────┘ │ │ │
│ │ └────────────────────────────┘ │ │
│ └────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────────────────────┘
│
┌──────────────────────────────┼──────────────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────────────────┐ ┌───────────────────────────┐ ┌───────────────────────────┐
│ BASIC CHATBOT │ │ CHATBOT WITH TOOLS │ │ AI NEWS AGENT │
│ │ │ │ │ │
│ ┌─────────────────────┐ │ │ ┌─────────────────────┐ │ │ ┌─────────────────────┐ │
│ │ START │ │ │ │ START │ │ │ │ FETCH NEWS │ │
│ │ │ │ │ │ │ │ │ │ │ │ (Tavily API) │ │
│ │ ▼ │ │ │ │ ▼ │ │ │ │ │ │ │
│ │ ┌─────────┐ │ │ │ │ ┌─────────┐ │ │ │ │ ▼ │ │
│ │ │ CHATBOT │ │ │ │ │ │ CHATBOT │◀─┐ │ │ │ │ ┌─────────────┐ │ │
│ │ │ NODE │ │ │ │ │ │ NODE │ │ │ │ │ │ │ SUMMARIZE │ │ │
│ │ └────┬────┘ │ │ │ │ └────┬────┘ │ │ │ │ │ │ (LLM) │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ └──────┬──────┘ │ │
│ │ ▼ │ │ │ │ ┌────▼────┐ │ │ │ │ │ │ │ │
│ │ END │ │ │ │ │ TOOLS │──┘ │ │ │ │ ▼ │ │
│ └─────────────────────┘ │ │ │ │ NODE │ │ │ │ │ ┌─────────────┐ │ │
│ │ │ │ └────┬────┘ │ │ │ │ │ SAVE RESULT │ │ │
│ Flow: Simple LLM call │ │ │ │ │ │ │ │ │ (Markdown) │ │ │
│ │ │ │ ▼ │ │ │ │ └──────┬──────┘ │ │
│ │ │ │ END │ │ │ │ │ │ │
│ │ │ └─────────────────────┘ │ │ │ ▼ │ │
│ │ │ │ │ │ END │ │
│ │ │ Flow: Conditional loop │ │ │ │ │
│ │ │ with tool execution │ │ └─────────────────────┘ │
│ │ │ │ │ │
└───────────────────────────┘ └───────────────────────────┘ │ Flow: Sequential │
│ pipeline processing │
└───────────────────────────┘
# Centralized State Definition using TypedDict
class State(TypedDict):
messages: Annotated[list, add_messages] # Auto-accumulating message history┌────────────────────────────────────────────────────────────────────┐
│ STATE LIFECYCLE │
├────────────────────────────────────────────────────────────────────┤
│ │
│ User Input ──▶ State[messages] ──▶ Node Processing ──▶ Update │
│ │ │ │ │ │
│ │ │ │ │ │
│ │ ┌────▼────┐ ┌────▼────┐ ┌────▼────┐ │
│ │ │ Message │ │ LLM │ │ New │ │
│ │ │ List │ │Response │ │ State │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │
│ └────────────────────────────────────────────────────┘ │
│ Feedback Loop │
│ │
└────────────────────────────────────────────────────────────────────┘
|
|
|
|
✅ Stateful Conversations - Messages persist across interactions
✅ Tool Integration - Seamless external API integration
✅ Multi-Model Support - Groq (Llama 3.3, Qwen, GPT-oss)
✅ Real-time Search - Live web data via Tavily
✅ Automated Reports - Self-generating news summaries
✅ Modular Design - Easy to extend and modify
✅ Production Ready - Error handling & validation
✅ Clean UI - Intuitive Streamlit interface
| Category | Technologies |
|---|---|
| Framework |   |
| LLM Provider |  |
| Frontend |  |
| Search API |  |
| Language |  |
langchain # Core LLM orchestration
langgraph # Stateful graph workflows
langchain-groq # Groq LLM integration
streamlit # Web UI framework
tavily-python # Web search API
python-dotenv # Environment management
faiss-cpu # Vector similarity search
sentence-transformers # Text embeddings
Agentic-Chatbot/
│
├── 📄 app.py # Application entry point
├── 📄 requirements.txt # Python dependencies
├── 📄 README.md # Project documentation
│
├── 📁 AINews/ # Generated news summaries
│ ├── 📰 daily_summary.md # Daily AI news digest
│ ├── 📰 weekly_summary.md # Weekly AI news digest
│ └── 📰 monthly_summary.md # Monthly AI news digest
│
├── 📁 assets/ # UI screenshots & images
│ ├── 🖼️ UI.png # Main interface screenshot
│ ├── 🖼️ basic_chatbot_output.png # Basic chatbot demo
│ ├── 🖼️ chatbot_with_tool_output.png # Tool integration demo
│ └── 🖼️ ai_news_daily_output.png # News aggregator demo
│
└── 📁 src/
└── 📁 LangGraphAgenticAI/
├── 📄 __init__.py
├── 📄 main.py # Main orchestrator
│
├── 📁 graph/
│ └── 📄 graph_builder.py # LangGraph workflow builder
│
├── 📁 LLMS/
│ └── 📄 groq_llm.py # Groq LLM configuration
│
├── 📁 nodes/
│ ├── 📄 basic_chatbot_node.py # Simple chat node
│ ├── 📄 chatbot_with_tool_node.py # Tool-enabled chat node
│ └── 📄 ai_news_node.py # News processing nodes
│
├── 📁 state/
│ └── 📄 state.py # State definition (TypedDict)
│
├── 📁 tools/
│ └── 📄 search_tool.py # Tavily search integration
│
└── 📁 ui/
├── 📄 uiconfigfile.ini # UI configuration
├── 📄 uiconfigfile.py # Config parser
└── 📁 streamlitui/
├── 📄 load_ui.py # Streamlit UI builder
└── 📄 display_results.py # Output renderer
# Clone the repository
git clone https://github.com/BrijeshRakhasiya/Agentic-Chatbot.git
cd Agentic-Chatbot
# Create virtual environment
python -m venv venv
# Activate virtual environment
# Windows
venv\Scripts\activate
# macOS/Linux
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt# Start the Streamlit app
streamlit run app.py- Open the application in your browser (default:
http://localhost:8501) - Enter your Groq API Key in the sidebar
- Select your preferred LLM Model
- Choose a Use Case
- For tool-based features, enter your Tavily API Key
- Start chatting!
Streamlit-based user interface with sidebar configuration
Simple conversational AI with context retention
Real-time web search integration using Tavily API
Automated AI news fetching and summarization
Graph Flow:
START ──▶ chatbot_node ──▶ END
Implementation:
class BasicChatbotNode:
def process(self, state: State) -> dict:
return {"messages": self.llm.invoke(state['messages'])}Key Points:
- Direct LLM invocation
- State-based message history
- Simple request-response pattern
Graph Flow:
START ──▶ chatbot_node ◀──▶ tools_node ──▶ END
│ ▲
│ (conditional) │
└──────────────────┘
Implementation:
def chatbot_with_tools_build_graph(self):
tools = get_tools()
tool_node = create_tool_node(tools)
llm_with_tools = self.llm.bind_tools(tools)
self.graph_builder.add_node("chatbot", chatbot_node)
self.graph_builder.add_node("tools", tool_node)
self.graph_builder.add_conditional_edges("chatbot", tools_condition)Key Points:
- Uses
tools_conditionfor dynamic routing - Tavily search for real-time web data
- Automatic tool invocation based on LLM decision
Graph Flow:
fetch_news ──▶ summarize_news ──▶ save_result ──▶ END
Pipeline Steps:
| Step | Function | Description |
|---|---|---|
| 1 | fetch_news() |
Query Tavily API for AI news |
| 2 | summarize_news() |
LLM summarization with custom prompt |
| 3 | save_result() |
Generate markdown file output |
Key Points:
- Supports daily, weekly, monthly timeframes
- Chronological sorting (latest first)
- Automatic markdown report generation
The system automatically generates news summaries stored in the AINews/ folder:
# Daily AI News Summary
### 2025-12-29
- **22:08 IST** – FedEx launches an AI education program for its
global workforce, teaching employees responsible AI use.
[Source](https://www.investing.com/news/...)
- **20:45 IST** – Israeli PM Netanyahu discussed AI and smart
transportation with Elon Musk.
[Source](https://www.ynetnews.com/...)
- **12:36 IST** – China drafts world's first rules restricting
AI chatbots from influencing emotions.
[Source](https://www.cnbc.com/...)# Weekly AI News Summary
### 2025-12-26
- **Washington Post** – Amazon, Microsoft and Google pledged
$67.5 billion to India for data-centers and AI.
[Source](https://www.washingtonpost.com/...)
### 2025-12-25
- **Nvidia & Groq** – Nvidia signs licensing deal with AI-chip
startup Groq and hires its leadership.
[Source](https://www.nytimes.com/...)# Monthly AI News Summary
### 2025-12-11
- **$50 bn AI push in India** – Amazon and Microsoft pledge
more than $50 bn for AI infrastructure in India.
[Source](https://www.bbc.com/...)
### 2025-12-16
- **Google AI Centers** – Google.org pledges $8 million for
AI hubs in health, agriculture, education.
[Source](https://www.lokmattimes.com/...)📁 Full outputs available in:
AINews/daily_summary.md|AINews/weekly_summary.md|AINews/monthly_summary.md
from typing import Annotated
from langgraph.graph.message import add_messages
class State(TypedDict):
messages: Annotated[list, add_messages]- Uses
TypedDictfor type safety add_messagesreducer for automatic message accumulation
class GraphBuilder:
def __init__(self, model):
self.llm = model
self.graph_builder = StateGraph(State)
def setup_graph(self, usecase: str):
if usecase == 'Basic Chatbot':
self.basic_chatbot_build_graph()
elif usecase == 'Chatbot with Tool':
self.chatbot_with_tools_build_graph()
elif usecase == 'AI News':
self.ai_news_builder_graph()
return self.graph_builder.compile()from langchain_community.tools.tavily_search import TavilySearchResults
from langgraph.prebuilt import ToolNode
def get_tools():
return [TavilySearchResults(max_results=2)]
def create_tool_node(tools):
return ToolNode(tools=tools)[DEFAULT]
PAGE_TITLE = LangGraph: Build Stateful Agentic AI
LLM_OPTIONS = Groq
USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, AI News
GROQ_MODEL_OPTIONS = llama-3.3-70b-versatile, llama-3.1-8b-instant| Pattern | Application |
|---|---|
| Factory Pattern | GraphBuilder.setup_graph() creates appropriate graph based on use case |
| Strategy Pattern | Different node implementations for different behaviors |
| State Pattern | State TypedDict manages conversation state |
| Template Method | graph_builder.compile() finalizes graph construction |
- Multi-LLM Support - Add OpenAI, Anthropic, Gemini providers
- Memory Persistence - Store conversations in database
- RAG Integration - Document-based Q&A capabilities
- Voice Interface - Speech-to-text input support
- Authentication - User login and session management
- Docker Deployment - Containerized deployment
- API Endpoints - REST API for external integration
- Advanced Analytics - Usage tracking and insights
Contributions are welcome! Please feel free to submit a Pull Request.
- Fork the repository
- Create your feature branch (
git checkout -b feature/AmazingFeature) - Commit your changes (
git commit -m 'Add some AmazingFeature') - Push to the branch (
git push origin feature/AmazingFeature) - Open a Pull Request
This project is licensed under the MIT License - see the LICENSE file for details.
MIT License
Copyright (c) 2025 Brijesh Rakhasiya
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
