title	AgenticAI With Langgraph
emoji	🐨
colorFrom	blue
colorTo	red
sdk	streamlit
sdk_version	1.42.0
app_file	app.py
pinned	false
short_description	Refined langgraphAgenticAI

Overview

LanggraphAgenticAI is an end-to-end agentic AI project built using LangGraph, a powerful framework for creating and orchestrating AI agents. This project demonstrates the implementation of modular AI agents capable of performing various tasks such as conversational chatbots, AI news summarization, tool-augmented interactions, and more. It leverages large language models (LLMs) like Groq and OpenAI, integrates vector stores for efficient data retrieval, and provides an intuitive Streamlit-based user interface for seamless interaction.

The project showcases the power of agentic AI by structuring complex workflows into graph-based nodes, allowing for scalable, maintainable, and extensible AI applications.

Features

• Modular Agent Nodes: Pre-built nodes for different AI functionalities including:
  • Basic chatbot for conversational AI
  • AI news summarization and daily updates
  • Tool-augmented chatbot with external search capabilities
• Graph-Based Orchestration: Uses LangGraph to define and execute complex AI workflows
• Multiple LLM Support: Integrates with Groq and OpenAI models for flexible AI processing
• Vector Store Integration: Utilizes FAISS for efficient vector-based search and retrieval
• External Tool Integration: Incorporates Tavily for web search functionality
• Streamlit UI: User-friendly web interface for interacting with the AI agents
• Extensible Architecture: Easily add new nodes, tools, and capabilities

Installation

Prerequisites

• Python 3.8 or higher
• pip package manager

Steps

1. Clone the repository:

   git clone <repository-url>
   cd Agentic-Ai-Project

2. Install dependencies:

   pip install -r requirements.txt

3. Set up environment variables (if required):

   • Obtain API keys for Groq, OpenAI, and Tavily
   • Create a .env file in the root directory and add your keys:

     GROQ_API_KEY=your_groq_api_key
     OPENAI_API_KEY=your_openai_api_key
     TAVILY_API_KEY=your_tavily_api_key
     

Usage

1. Run the application:

   streamlit run app.py

2. Access the UI:

   • Open your web browser and navigate to the URL provided by Streamlit (usually http://localhost:8501)

3. Interact with the AI agents:

   • Use the Streamlit interface to select and interact with different AI nodes
   • Choose from available agents: Basic Chatbot, AI News Summarizer, Tool-Augmented Chatbot
   • Input your queries and receive AI-generated responses

Project Structure

Agentic-Ai-Project/
├── app.py                          # Main application entry point
├── requirements.txt                # Python dependencies
├── README.md                       # Project documentation
├── AINews/
│   └── daily_summary.md            # AI-generated news summaries
└── src/
    └── langgraphagenticai/
        ├── __init__.py
        ├── main.py                 # Main application logic
        ├── graph/
        │   ├── __init__.py
        │   └── graph_builder.py    # LangGraph construction
        ├── LLMS/
        │   ├── __init__.py
        │   └── groqllm.py          # LLM integrations
        ├── nodes/
        │   ├── __init__.py
        │   ├── ai_news_node.py     # AI news processing node
        │   ├── basic_chatbot_node.py  # Basic chatbot node
        │   └── chatbot_with_Tool_node.py  # Tool-augmented chatbot node
        ├── state/
        │   ├── __init__.py
        │   └── state.py            # Application state management
        ├── tools/
        │   ├── __init__.py
        │   └── serach_tool.py      # Search tool implementation
        ├── ui/
        │   ├── __init__.py
        │   ├── uiconfigfile.ini
        │   ├── uiconfigfile.py
        │   └── streamlitui/
        │       ├── display_result.py
        │       └── loadui.py       # Streamlit UI components
        └── vectorstore/
            ├── __init__.py
            └── [vector store files] # Vector database files

How It Works

1. Graph Construction: The graph_builder.py defines the LangGraph structure, connecting various nodes based on the workflow requirements.

2. Node Execution: Each node (e.g., basic_chatbot_node.py, ai_news_node.py) performs specific AI tasks using integrated LLMs and tools.

3. State Management: The state.py handles the application's state, ensuring smooth transitions between nodes and maintaining context.

4. Tool Integration: Tools like the search tool (serach_tool.py) enhance agent capabilities by providing external data access.

5. UI Interaction: The Streamlit UI (streamlitui/) provides an interface for users to interact with the AI agents, displaying results and handling user inputs.

Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

License

This project is proprietary and all rights are reserved by the author. © 2026

Acknowledgments

• LangGraph for the agent orchestration framework
• LangChain for LLM integrations
• Streamlit for the web UI framework
• FAISS for vector search capabilities
• Tavily for search API services