AI Chatbot (Groq + LLaMA 3.1) — Explanation

Overview

This project implements a web-based AI chatbot using Streamlit as the frontend and Groq-powered LLaMA 3.1 as the language model. The chatbot allows users to enter prompts related to AI research, trends, and summaries, processes them through an LLM backend, and displays the responses in a conversational chat interface. The application maintains chat history, provides a user-friendly UI, and simulates a real-time conversational experience.

Key Technologies Used

Streamlit – for building an interactive web interface
Groq + LLaMA 3.1 – for fast and high-quality LLM inference
Python – core programming language
Session State – to persist chat history across interactions

Code Explanation (Step-by-Step)

1. Importing Required Libraries

#(import streamlit as st
from llm import run_llm )

• Streamlit is used to build the web interface.
• run_llm is a custom function imported from llm.py that sends the user prompt to the Groq LLaMA 3.1 model and returns the AI-generated response.
  This separation keeps the frontend clean and delegates model logic to the backend.

2. Page Configuration

#(st.set_page_config(page_title="Groq Chatbot", page_icon="🤖")

• Sets the browser tab title and chatbot icon.
• Improves the overall UI and branding of the application.

3. Custom Chat Styling (UI Enhancement)

#(st.markdown("""
<style>
.chat-bubble-user {
    background-color: #DCF8C6;
    border-radius: 10px;
    padding: 8px 12px;
    margin: 6px 0px;
    width: fit-content;
    max-width: 75%;
}
.chat-bubble-ai {
    background-color: #F1F0F0;
    border-radius: 10px;
    padding: 8px 12px;
    margin: 6px 0px;
    width: fit-content;
    max-width: 75%;
}
</style>
""", unsafe_allow_html=True)

• Custom CSS is used to create chat bubbles.
• User messages and AI responses have different colors, making the conversation visually clear.
• This enhances user experience and mimics modern chat applications.

4. Application Title

#(st.title("🤖 AI Chatbot (Groq+ LLaMA 3.1)")

• Displays the main heading of the chatbot interface.
• Clearly communicates the underlying technology used.

5. Initializing Chat History

#(if "chat_history" not in st.session_state:
    st.session_state.chat_history= [])

• Uses Streamlit’s session state to store conversation history.
• Ensures chat messages persist even after user interactions like button clicks.
• Each message is stored as a tuple: (role, message).

6. User Input Section

#(prompt= st.text_area(
    "Your Prompt:",
    placeholder="Ask anything about AI research, trends, summaries..."
)

• Provides a multi-line text input for user queries.
• The placeholder guides users on the type of questions they can ask.
  ##7. Generating AI Responses

#(if st.button("Send"):
    if prompt.strip():
        with st.spinner("Thinking....."):
            response= run_llm(prompt)

            st.session_state.chat_history.append(("You", prompt))
            st.session_state.chat_history.append(("AI", response))
    else:
        st.warning("Please type something first.")

Logic Explanation:

When the Send button is clicked:

• Empty inputs are blocked using validation.
• A spinner indicates that the AI is processing the request.
• The prompt is sent to the LLM via run_llm().
• Both the user query and AI response are saved in chat history.
• This makes the chatbot interactive and stateful.

8. Displaying Chat History

#(st.write("---")
st.subheader("Chat History")
- [ ] Adds a separator and heading for clarity.
for role, message in st.session_state.chat_history:
    if role== "You":
        st.markdown(
            f"<div class='chat-bubble-user'><b>You:</b> {message}</div>",
            unsafe_allow_html=True
        )
    else:
        st.markdown(
            f"<div class='chat-bubble-ai'><b>AI:</b> {message}</div>",
            unsafe_allow_html=True
        )

• Iterates through stored messages.
• Applies different styles based on message role (User vs AI).
• Results in a clean conversational UI.

Why This Project Is Important

• Demonstrates LLM integration using Groq for fast inference.
• Shows real-world chatbot architecture with frontend–backend separation.
• Uses state management, which is critical for conversational AI systems.
• Acts as a foundation for building agentic systems, customer support bots, or research assistants.

Conclusion

This AI Chatbot project effectively combines Streamlit UI, Groq-powered LLaMA 3.1, and session-based memory to create a responsive, user-friendly conversational application.
It reflects modern AI application design principles and serves as a strong base for extending into AI agents, tool usage, or autonomous workflows.

LLM Integration Module (Groq + LLaMA 3.1)

Overview

1. This file is responsible for connecting the application with the Groq API and running the LLaMA 3.1 language model.
2. It acts as the backend intelligence layer of the chatbot, handling prompt processing and response generation.
3. The frontend (Streamlit app) communicates with this module to fetch AI-generated responses.

Purpose of This File

a. Securely load the Groq API key
b. Initialize the Groq client
c. Send user prompts to the LLaMA 3.1 model
d. Receive and return AI-generated responses
e. This separation ensures clean architecture and modular design.

Code Explanation (Step-by-Step)

1. Importing Required Libraries

#(import os
from dotenv import load_dotenv
from groq import Groq)

• os is used to access environment variables.
• dotenv helps load environment variables from a .env file.
• Groq is the official Groq client used to interact with LLM models.

2. Loading Environment Variables

#(load_dotenv()

• Loads variables from the .env file into the runtime environment.
• Ensures sensitive data (like API keys) is not hardcoded.
• This is a best practice for security and deployment.

3. Fetching the API Key

#(GROQ_API_KEY = os.getenv("GROQ_API_KEY")

• Retrieves the Groq API key from environment variables.
• Keeps credentials secure and configurable.

4. API Key Validation

#(if not GROQ_API_KEY:
    raise ValueError("GROQ_API_KEY not found! Make sure it is set in your.env file.")

• Ensures the application does not run without a valid API key.
• Prevents silent failures and helps in debugging.
• Enforces proper environment configuration.

5. Initializing the Groq Client

#(client = Groq(api_key=GROQ_API_KEY)

• Creates a Groq client instance.
• This client is responsible for sending requests to the LLaMA model.
• Acts as the communication bridge between the application and the LLM.

6. Defining the run_llm Function

#(def run_llm(prompt: str, max_tokens: int = 300):

• This function serves as the core inference function.

Parameters:

• prompt: user input text
• max_tokens: controls the length of the model’s response
• This design allows flexibility and reuse across different applications.

7. Sending Prompt to the LLM

#(response = client.chat.completions.create(
    model="llama-3.1-8b-instant",
    messages=[{"role": "user", "content": prompt}],
    max_tokens=max_tokens
)

• Uses Groq’s chat completion API.
• Model used: LLaMA 3.1 8B Instant, optimized for speed and low latency.
• Messages follow the chat format, making it compatible with conversational AI.
• max_tokens limits the response size for efficiency.

8. Returning the AI Response

#(return response.choices[0].message.content)

• Extracts the generated text from the model response.
• Returns a clean text output back to the Streamlit frontend.

9. Debugging & Verification

#(print("Loaded Key: ", GROQ_API_KEY)

• Confirms that the API key has been loaded successfully.
• Helpful during development and testing.

10. Standalone Testing Block

#(if __name__ == "__main__":
    reply = run_llm("Hello, how are you?")
    print(reply)

• Allows the file to be run independently.
• Tests whether the LLM integration is working correctly.
• Ensures backend reliability before integrating with the frontend.

Architectural Importance

Keeps LLM logic separate from the UI
Improves maintainability and scalability
Makes it easy to:

1. Switch models
2. Add system prompts
3. Extend to agentic workflows later
4. This structure follows industry-level backend design practices.

Conclusion

This module serves as the brain of the chatbot, enabling seamless communication with the Groq-powered LLaMA 3.1 model.
By securely managing API keys, abstracting model interaction, and providing a reusable inference function, it lays a strong foundation for building scalable AI chatbots and future agentic systems.