Add Grok API support and improve LLM integration

.gitignore

@@ -5,6 +5,11 @@
 # instagram_cookies.txt should not be tracked by git because it has cookies
 instagram_cookies.txt
 
+# SQLite database
+src/data/
+*.db
+*.db-journal
+
 # Byte-compiled / optimized / compiled Python files
 __pycache__/
 *.py[cod]

Dockerfile

@@ -19,6 +19,9 @@ COPY src /bot
 
 WORKDIR /bot
 
+# Create data directory for SQLite database
+RUN mkdir -p /bot/data
+
 # https://stackoverflow.com/questions/58701233/docker-logs-erroneously-appears-empty-until-container-stops
 ENV PYTHONUNBUFFERED=1
 

README.md

@@ -27,13 +27,21 @@ docker build . -t downloader-bot:latest
 ```
 docker run -d --name downloader-bot --restart always --env-file .env downloader-bot:latest
 ```
+To persist user data (conversation history, rate limits) between restarts, add a volume:
+```
+docker run -d --name downloader-bot --restart always --env-file .env -v bot-data:/bot/data downloader-bot:latest
+```
 or use a built image from **Docker hub**
 ```
 docker run -d --name downloader-bot --restart always --env-file .env ovchynnikov/load-bot-linux:latest
 ```
+With persistent data:
+```
+docker run -d --name downloader-bot --restart always --env-file .env -v bot-data:/bot/data ovchynnikov/load-bot-linux:latest
+```
 or if you use instagram cookies
 ```
-docker run -d --name downloader-bot --restart always --env-file .env -v /absolute/path/to/instagram_cookies.txt:/bot/instagram_cookies.txt ovchynnikov/load-bot-linux:latest
+docker run -d --name downloader-bot --restart always --env-file .env -v bot-data:/bot/data -v /absolute/path/to/instagram_cookies.txt:/bot/instagram_cookies.txt ovchynnikov/load-bot-linux:latest
 ```
 or if you want use GPU power of intel chip and set USE_GPU_COMPRESSING=True variable
 ```

docker-compose.yml

@@ -10,8 +10,13 @@ services:
     restart: unless-stopped
     volumes:
       - ./src:/app:cached  # Use bind mount for development
+      - bot-data:/bot/data  # Persistent storage for SQLite database
     deploy:
       resources:
         limits:
           cpus: '1'
           memory: 512M
+
+volumes:
+  bot-data:
+    driver: local

src/db_storage.py

@@ -0,0 +1,87 @@
+"""SQLite storage for bot user data persistence."""
+
+import sqlite3
+import json
+import os
+import time
+from logger import debug
+
+
+class BotStorage:
+    """Handles persistent storage of user data in SQLite."""
+
+    def __init__(self, db_path="data/bot.db"):
+        """Initialize database connection and create tables."""
+        os.makedirs(os.path.dirname(db_path), exist_ok=True)
+        self.db_path = db_path
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self._create_tables()
+        debug("Database initialized at %s", db_path)
+
+    def _create_tables(self):
+        """Create tables if they don't exist."""
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS user_data (
+                user_id INTEGER PRIMARY KEY,
+                conversation_context TEXT,
+                rate_limit_timestamps TEXT,
+                daily_count INTEGER DEFAULT 0,
+                daily_date TEXT,
+                last_seen REAL
+            )
+        """)
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_user_data_last_seen ON user_data(last_seen)")
+        self.conn.commit()
+
+    def load_user_data(self, user_id):
+        """Load user data from database."""
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT * FROM user_data WHERE user_id = ?", (user_id,))
+        row = cursor.fetchone()
+        if row:
+            return {
+                "conversation_context": json.loads(row[1]) if row[1] else [],
+                "rate_limit_timestamps": json.loads(row[2]) if row[2] else [],
+                "daily_count": row[3],
+                "daily_date": row[4],
+                "last_seen": row[5],
+            }
+        return None
+
+    def save_user_data(self, user_id, conversation_context, rate_limit_timestamps, daily_count, daily_date, last_seen):
+        """Save user data to database."""
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            INSERT OR REPLACE INTO user_data 
+            (user_id, conversation_context, rate_limit_timestamps, daily_count, daily_date, last_seen)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                user_id,
+                json.dumps(conversation_context),
+                json.dumps(rate_limit_timestamps),
+                daily_count,
+                daily_date,
+                last_seen,
+            ),
+        )
+        self.conn.commit()
+
+    def delete_user_data(self, user_id):
+        """Delete user data from database."""
+        cursor = self.conn.cursor()
+        cursor.execute("DELETE FROM user_data WHERE user_id = ?", (user_id,))
+        self.conn.commit()
+
+    def get_stale_users(self, ttl_seconds):
+        """Get list of user IDs that haven't been seen within TTL."""
+        current_time = time.time()
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT user_id FROM user_data WHERE last_seen < ?", (current_time - ttl_seconds,))
+        return [row[0] for row in cursor.fetchall()]
+
+    def close(self):
+        """Close database connection."""
+        self.conn.close()