Hugging Face's logo

Spaces:
yashAI007
/
Chatbot
Running

App Files Community
Chatbot / README1.md
yashAI007's picture
yashAI007
update README.md with claud
6b470db
preview code
|
raw
history blame contribute delete
9.43 kB

A newer version of the Gradio SDK is available: 6.10.0

Upgrade
metadata 
title: Chatbot
emoji: 💻
colorFrom: yellow
colorTo: green
sdk: gradio
sdk_version: 6.6.0
app_file: app.py
pinned: false
short_description: Chatbot

Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

Multi-User Memory Chatbot with LangChain, Tools, and Gradio

A conversational AI chatbot built with LangChain, Gradio, and multiple custom tools.
This project supports:

  • multi-user chat sessions
  • multiple threads per user
  • memory-aware conversations
  • tool calling
  • optional tool activity display in the UI

It is useful for experimenting with AI agents that can search, calculate, scrape websites, fetch weather, read files, and more.

Features

  • 👤 Multiple users
  • 🧵 Multiple chat threads per user
  • 🧠 Conversation memory using thread_id and user_id
  • 🛠 Tool-enabled chatbot
  • 🌐 Web search using Tavily
  • 📚 Wikipedia search
  • ☁️ Weather lookup
  • 🧮 Calculator
  • 🐍 Python code execution
  • 📄 Read local files
  • 🔎 Scrape webpage text
  • 🧾 Pretty-print JSON
  • 💾 Save user preferences
  • 🖥 System info tool
  • 🎨 Gradio web interface
  • ✅ Optional tool activity panel to show which tools were called

Project Structure

A recommended project structure:

project/
│
├── tools.py               # All tool definitions
├── memory_chatbot.py      # Chatbot / LangChain agent backend
├── app.py                 # Gradio UI
├── .env                   # Environment variables
├── requirements.txt       # Python dependencies
└── README.md

Important:
If your UI file imports chatbot like this:

from memory_chatbot import chatbot

then your UI file should not also be named memory_chatbot.py, otherwise you may get a circular import error.
Use a separate file name such as app.py for the Gradio interface.

Tools Included

The project currently includes the following tools:

1. time_date

Returns today’s date in yyyy-mm-dd format.

2. calculator

Evaluates mathematical expressions.

3. python_exec

Executes Python code and returns local variables.

4. get_weather

Fetches current weather for a city using wttr.in.

5. wikipedia_search

Searches Wikipedia and returns a short summary.

6. scrape_website

Extracts text content from a webpage.

7. read_file

Reads the contents of a local file.

8. format_json

Formats and prettifies a JSON string.

9. generate_sql

Converts natural language into a placeholder SQL query.

10. system_info

Returns system/platform information.

11. save_user_preference

Stores user preference text (currently mocked).

12. tool_tavily

Performs web search using Tavily.

Installation

1. Clone the repository 

git clone https://github.com/your-username/your-repo-name.git
cd your-repo-name

2. Create a virtual environment

Windows 

python -m venv venv
venv\Scripts\activate

macOS / Linux 

python3 -m venv venv
source venv/bin/activate

3. Install dependencies 

pip install -r requirements.txt

If you do not already have a requirements.txt, you can use something like this:

gradio
langchain
langchain-core
langchain-tavily
python-dotenv
requests
wikipedia
beautifulsoup4

Depending on your chatbot backend, you may also need your model provider package, such as:

  • langchain-openai
  • langchain-google-genai
  • langchain-groq
  • or another LLM integration

Environment Variables

Create a .env file in the root directory.

Example:

TAVILY_API_KEY=your_tavily_api_key
OPENAI_API_KEY=your_openai_api_key

If you are using another model provider, replace OPENAI_API_KEY with the correct key for your setup.

Running the App

Start the Gradio interface with:

python app.py

Then open the local Gradio URL shown in the terminal, usually:

http://127.0.0.1:7860

How It Works

User and Thread Management

Each conversation is identified using:

  • user_id
  • thread_id

This allows the chatbot to maintain separate memory for:

  • different users
  • different chat sessions for the same user

Chat Flow

When the user sends a message:

  1. the message is wrapped as a HumanMessage
  2. the chatbot is invoked with thread_id and user_id
  3. the agent may call one or more tools
  4. the final AI response is displayed in the chat UI
  5. the conversation is stored under that user/thread pair

Gradio UI Features

The Gradio app includes:

  • User selector
  • New user button
  • Thread selector
  • New chat button
  • Chat area
  • Message input box

This makes it easy to simulate multiple users and sessions in one interface.

Showing Tool Calls in the UI

Yes — this project can be extended to show:

  • which tool was called
  • tool arguments
  • tool output

For example, if the chatbot uses get_weather("Delhi"), the UI can display something like:

Calling tool: get_weather
Arguments: {"city": "Delhi"}
Output: Delhi: +34°C, Sunny

This is useful for:

  • debugging
  • understanding agent behavior
  • teaching/demo purposes

A good way to display this is by adding a gr.Markdown() or gr.Textbox() panel in the UI and parsing:

  • AIMessage.tool_calls
  • ToolMessage.content

Example Use Cases

  • Ask today’s date
  • Calculate expressions like 25 * 12
  • Execute small Python snippets
  • Look up weather in a city
  • Search Wikipedia topics
  • Scrape a webpage summary
  • Read a local file
  • Format JSON data
  • Save user preferences

Example Prompts

Try asking:

What is today's date?

Calculate 125 * 48

What is the weather in London?

Search Wikipedia for Artificial Intelligence

Read the contents of sample.txt

Format this JSON: {"name":"John","age":25}

Security Warning

This project includes some tools that are unsafe for public deployment without restrictions.

Risky tools

  • calculator uses eval()
  • python_exec uses exec()
  • read_file can access local files
  • scrape_website can fetch arbitrary URLs

Why this matters

If exposed publicly, users may be able to:

  • run arbitrary Python code
  • read sensitive local files
  • access internal resources
  • misuse the server

Recommendation

Use this project:

  • for local development
  • for learning
  • for internal testing only

Before deploying publicly, you should:

  • remove eval() and exec()
  • restrict file access
  • validate URLs
  • sandbox execution
  • add authentication and rate limiting

Tiny chatbot, big chaos potential. Better to keep the chaos leashed.

Known Notes

1. Circular Import Risk

If your UI file is named memory_chatbot.py and also contains:

from memory_chatbot import chatbot

you will likely get an import issue.

Fix

Rename the Gradio UI file to something like:

app.py

and keep the chatbot backend in:

memory_chatbot.py

2. Tool Results May Differ

Some tools depend on external services:

  • wttr.in
  • Wikipedia
  • Tavily
  • websites being scraped

If those services are unavailable, the tool may fail or return unexpected results.

Future Improvements

Possible enhancements for this project:

  • real memory store integration
  • persistent database for chat history
  • streaming responses
  • live tool-call updates in the UI
  • better error handling
  • authentication
  • safer code execution sandbox
  • SQL generation using LLM
  • file upload support
  • improved styling for the chat interface

Sample tools.py

This file contains all your custom tools used by the chatbot agent.

It includes tools for:

  • date/time
  • calculator
  • Python execution
  • weather
  • Wikipedia
  • web scraping
  • file reading
  • JSON formatting
  • SQL generation
  • system information
  • user preference saving
  • Tavily search

Sample Workflow

  1. Start app
  2. Select or create a user
  3. Create a new thread
  4. Ask a question
  5. Agent decides whether to use tools
  6. Tool result is returned
  7. Final AI answer is shown
  8. Conversation history is stored per user/thread

Requirements Summary

Main libraries used:

  • gradio
  • langchain
  • langchain-core
  • langchain-tavily
  • requests
  • wikipedia
  • beautifulsoup4
  • python-dotenv

License

This project is for educational and development use.
Add your preferred license here, for example:

MIT License

Author

Built with LangChain, Gradio, and a healthy amount of agent curiosity.

If you want, you can customize this section with your name, GitHub profile, or portfolio link.

Contributing

Contributions are welcome.

You can improve this project by:

  • adding safer tool implementations
  • improving UI design
  • adding persistent memory
  • improving tool logging
  • integrating streaming
  • adding tests

Final Notes

This project is a great starting point if you want to learn:

  • LangChain tools
  • agent-based workflows
  • memory-aware chat apps
  • multi-thread chat management
  • Gradio interfaces

If you are planning to deploy it publicly, please review the security concerns carefully before doing so.