bharat chatbot groq Download - bharat chatbot groq Quellcode herunterladen

bharat chatbot groq

AI-Quellcode

1.0.0

Herunterladen

Bharat ChatAI

Bharat ChatAI ist eine KI-gestützte Chatbot-Anwendung, die verschiedene KI-Modelle und Dokumentenverarbeitungsfunktionen integriert. Mit dieser Anwendung können Benutzer mithilfe verschiedener Modelle mit der KI chatten, Dokumente hochladen und verarbeiten sowie Informationen von URLs abrufen.

Inhaltsverzeichnis

Installation
Verwendung
Docker-Setup
AWS EC2-Bereitstellung
Dateistruktur
Codeübersicht
- Konfig
- DocumentProcessor
- ChatHandler
- ToolsAndAgentsInitializer
- BharatChatAI
- StreamlitInterface
Lizenz
Kontakt

Installation

Klonen Sie das Repository:

git clone https://github.com/itsmohitkumar/bharat-chatbot-groq.git
cd bharat-chatbot-groq

Erstellen Sie eine virtuelle Umgebung und aktivieren Sie sie:

python -m venv env
source env/bin/activate  # On Windows, use `envScriptsactivate`

Installieren Sie die erforderlichen Pakete:
```
pip install -r requirements.txt
```
Erstellen Sie eine .env Datei im Projektstammverzeichnis und fügen Sie Ihren API-Schlüssel hinzu:
```
 GROQ_API_KEY=your_api_key_here
```

Verwendung

Führen Sie die Streamlit-Anwendung aus:

streamlit run app.py

Docker-Setup

Gehen Sie folgendermaßen vor, um die Bharat ChatAI-Anwendung mithilfe von Docker zu containerisieren:

Erstellen Sie eine Docker-Datei: Erstellen Sie im Stammverzeichnis Ihres Projekts eine Dockerfile mit folgendem Inhalt:

 # Use an official Python runtime as a parent image
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Make port 8501 available to the world outside this container
EXPOSE 8501

# Define environment variable
ENV GROQ_API_KEY=your_api_key_here

# Run the application
CMD [ "streamlit" , "run" , "app.py" ]

Erstellen Sie das Docker-Image: Führen Sie den folgenden Befehl im Terminal aus, um Ihr Docker-Image zu erstellen:
```
docker build -t bharat-chatai .
```
Führen Sie den Docker-Container aus: Nachdem das Image erstellt wurde, können Sie die Anwendung in einem Container ausführen mit:
```
docker run -p 8501:8501 bharat-chatai
```
Auf die Anwendung kann unter http://localhost:8501 zugegriffen werden.

AWS EC2-Bereitstellung

Führen Sie die folgenden Schritte aus, um die Bharat ChatAI-Anwendung auf AWS EC2 bereitzustellen:

Starten Sie eine EC2-Instanz:
- Gehen Sie zum AWS EC2 Dashboard und starten Sie eine neue Instanz.
- Wählen Sie ein Amazon Machine Image (AMI), z. B. Ubuntu Server 20.04 LTS.
- Wählen Sie einen Instanztyp aus, zum Beispiel t2.micro (kostenloses Kontingent möglich).
- Konfigurieren Sie die Instanzdetails und den Speicher und fügen Sie bei Bedarf Tags hinzu.
- Konfigurieren Sie unter „Sicherheitsgruppe“ eine Regel, um HTTP-Verkehr (Port 80) und Port 8501 für Streamlit zuzulassen.
Stellen Sie eine Verbindung zur EC2-Instanz her:
- Verwenden Sie SSH, um eine Verbindung zu Ihrer Instanz herzustellen:
```
ssh -i " your-key.pem " [email protected]
```

Installieren Sie Docker auf der EC2-Instanz:

sudo apt update
sudo apt install docker.io
sudo systemctl start docker
sudo systemctl enable docker

Klonen Sie das Bharat ChatAI-Repository:

git clone https://github.com/itsmohitkumar/bharat-chatbot-groq.git
cd bharat-chatbot-groq

Erstellen Sie den Docker-Container und führen Sie ihn aus:
- Befolgen Sie die obigen Docker-Setup-Anweisungen, um den Container auf der EC2-Instanz zu erstellen und auszuführen:
```
sudo docker build -t bharat-chatai .
sudo docker run -p 80:8501 bharat-chatai
```
Greifen Sie auf die Anwendung zu:
- Sobald der Container ausgeführt wird, können Sie auf die Anwendung zugreifen, indem Sie in Ihrem Browser zur öffentlichen IP der EC2-Instanz navigieren ( http://ec2-xx-xx-xx-xx.compute-1.amazonaws.com ).

Dateistruktur

Die Dateistruktur des Projekts ist wie folgt:

 bharat-chatai/
├── src/
│   ├── __init__.py
│   ├── logger.py
│   ├── prompt.py
│   ├── bharatchat/
│   │   ├── __init__.py
│   │   └── chatbot.py
├── setup.py
├── app.py

src/__init__.py : Initialisierungsdatei für das src -Paket.
src/logger.py : Modul zur Protokollierungskonfiguration.
src/prompt.py : Modul zum Definieren von Eingabeaufforderungsvorlagen.
src/bharatchat/__init__.py : Initialisierungsdatei für das bharatchat -Paket.
src/bharatchat/chatbot.py : Hauptmodul für die Chatbot-Logik.
setup.py : Setup-Skript für das Paket.
app.py : Hauptanwendungsdatei zum Ausführen der Streamlit-Schnittstelle.

Codeübersicht

Konfig

Die Config -Klasse übernimmt die Konfiguration der Anwendung, einschließlich des Abrufens des API-Schlüssels und des Abrufens verfügbarer Modelloptionen von der Groq-API.

DocumentProcessor

Die DocumentProcessor Klasse verarbeitet Dokumente aus hochgeladenen Dateien oder URLs, teilt sie in Blöcke auf und speichert sie in einem FAISS-Vektorspeicher. Außerdem werden Zusammenfassungen der verarbeiteten Dokumente erstellt.

ChatHandler

Die ChatHandler Klasse verarbeitet Chat-Anfragen, zeigt den Chat-Verlauf an und ruft Antworten mithilfe der Dokumentvektoren ab.

ToolsAndAgentsInitializer

Die ToolsAndAgentsInitializer -Klasse initialisiert die Tools und Agenten für die Chat-Schnittstelle, einschließlich der Einrichtung des Modells und der Erstellung kombinierter Ketten für die Dokumenten- und Abfrageverarbeitung.

BharatChatAI

Die BharatChatAI Klasse initialisiert die Anwendung, einschließlich Einbettungen, Dokumentverarbeitung und Chat-Verarbeitung. Es führt auch die Streamlit-App-Schnittstelle aus.

StreamlitInterface

Die StreamlitInterface Klasse rendert die Streamlit-App-Oberfläche, einschließlich der Initialisierung der Seitenleiste und der Handhabung von Benutzerauswahlen.