| --- |
| 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: |
|
|
| ```text |
| 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: |
|
|
| ```python |
| 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 |
|
|
| ```bash |
| git clone https://github.com/your-username/your-repo-name.git |
| cd your-repo-name |
| ``` |
|
|
| ## 2. Create a virtual environment |
|
|
| ### Windows |
|
|
| ```bash |
| python -m venv venv |
| venv\Scripts\activate |
| ``` |
|
|
| ### macOS / Linux |
|
|
| ```bash |
| python3 -m venv venv |
| source venv/bin/activate |
| ``` |
|
|
| ## 3. Install dependencies |
|
|
| ```bash |
| pip install -r requirements.txt |
| ``` |
|
|
| If you do not already have a `requirements.txt`, you can use something like this: |
|
|
| ```txt |
| 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: |
|
|
| ```env |
| 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: |
|
|
| ```bash |
| python app.py |
| ``` |
|
|
| Then open the local Gradio URL shown in the terminal, usually: |
|
|
| ```text |
| 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: |
|
|
| ```text |
| 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: |
|
|
| ```text |
| What is today's date? |
| ``` |
|
|
| ```text |
| Calculate 125 * 48 |
| ``` |
|
|
| ```text |
| What is the weather in London? |
| ``` |
|
|
| ```text |
| Search Wikipedia for Artificial Intelligence |
| ``` |
|
|
| ```text |
| Read the contents of sample.txt |
| ``` |
|
|
| ```text |
| 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: |
|
|
| ```python |
| from memory_chatbot import chatbot |
| ``` |
|
|
| you will likely get an import issue. |
|
|
| ### Fix |
|
|
| Rename the Gradio UI file to something like: |
|
|
| ```text |
| app.py |
| ``` |
|
|
| and keep the chatbot backend in: |
|
|
| ```text |
| 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: |
|
|
| ```text |
| 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. |
