used Gradio

Dockerfile

@@ -54,3 +54,4 @@ EXPOSE 8000
 
 # Use a startup script with debug output
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--log-level", "debug"]
+

README.md

@@ -12,4 +12,18 @@ short_description: It is a chat built with an AI model about www.Status.law
 
 # LS DOC Chatbot Log
 
-It is a chat app built using Hugging Face and Docker Space that allows users to interact with an AI model to communicate about www.Status.law
+It is a chat app built using Hugging Face and Docker Space that allows users to interact with an AI model to communicate about www.Status.law
+
+This application provides two interfaces:
+1. Web Interface (accessible via /web endpoint)
+2. Hugging Face Spaces Interface (using Gradio)
+
+## Access Points
+- Web Interface: http://localhost:8000/web
+- Gradio Interface: http://localhost:7860
+- API Endpoints: http://localhost:8000/docs
+
+## Environment Variables
+Required environment variables:
+- GROQ_API_KEY
+- HF_TOKEN (optional, for Hugging Face integration)

app - Copy.py

@@ -1,417 +0,0 @@
-import os
-import time
-from dotenv import load_dotenv
-from langchain_groq import ChatGroq
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_core.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from datetime import datetime
-import json
-import traceback
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from api import router as analysis_router
-from utils import ChatAnalyzer, setup_chat_analysis
-import requests.exceptions
-import aiohttp
-from typing import Union
-import uvicorn
-import logging
-from rich import print as rprint
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-
-console = Console()
-
-# Базовая настройка логирования
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-# Определение путей
-VECTOR_STORE_PATH = os.path.join(os.getcwd(), "vector_store")
-CHAT_HISTORY_PATH = os.path.join(os.getcwd(), "chat_history")
-
-app = FastAPI(title="Status Law Assistant API")
-
-class ChatRequest(BaseModel):
-    message: str
-
-class ChatResponse(BaseModel):
-    response: str
-
-def check_vector_store():
-    """Проверка наличия векторной базы"""
-    index_path = os.path.join(VECTOR_STORE_PATH, "index.faiss")
-    return os.path.exists(index_path)
-
-@app.get("/")
-async def root():
-    """Базовый эндпоинт с информацией о состоянии"""
-    return {
-        "status": "ok",
-        "vector_store_ready": check_vector_store(),
-        "timestamp": datetime.now().isoformat()
-    }
-
-@app.get("/status")
-async def get_status():
-    """Получение статуса векторной базы"""
-    return {
-        "vector_store_exists": check_vector_store(),
-        "can_chat": check_vector_store(),
-        "vector_store_path": VECTOR_STORE_PATH
-    }
-
-@app.post("/build-knowledge-base")
-async def build_kb():
-    """Эндпоинт для построения базы знаний"""
-    try:
-        if check_vector_store():
-            return {
-                "status": "exists",
-                "message": "Knowledge base already exists"
-            }
-        
-        # Инициализируем embeddings только когда нужно построить базу
-        embeddings = HuggingFaceEmbeddings(
-            model_name="sentence-transformers/all-MiniLM-L6-v2"
-        )
-        vector_store = build_knowledge_base(embeddings)
-        
-        return {
-            "status": "success",
-            "message": "Knowledge base built successfully"
-        }
-    except Exception as e:
-        logger.error(f"Failed to build knowledge base: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Failed to build knowledge base: {str(e)}"
-        )
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(request: ChatRequest):
-    """Эндпоинт чата"""
-    if not check_vector_store():
-        raise HTTPException(
-            status_code=400,
-            detail="Knowledge base not found. Please build it first using /build-knowledge-base endpoint"
-        )
-    
-    try:
-        # Инициализируем компоненты только при необходимости
-        llm = ChatGroq(
-            model_name="llama-3.3-70b-versatile",
-            temperature=0.6,
-            api_key=os.getenv("GROQ_API_KEY")
-        )
-        
-        embeddings = HuggingFaceEmbeddings(
-            model_name="sentence-transformers/all-MiniLM-L6-v2"
-        )
-        
-        vector_store = FAISS.load_local(
-            VECTOR_STORE_PATH,
-            embeddings,
-            allow_dangerous_deserialization=True
-        )
-
-        # Остальная логика чата...
-        context_docs = vector_store.similarity_search(request.message)
-        context_text = "\n".join([d.page_content for d in context_docs])
-        
-        prompt_template = PromptTemplate.from_template('''
-            You are a helpful and polite legal assistant at Status Law.
-            Answer the question based on the context provided.
-            Context: {context}
-            Question: {question}
-        ''')
-        
-        chain = prompt_template | llm | StrOutputParser()
-        response = chain.invoke({
-            "context": context_text,
-            "question": request.message
-        })
-        
-        return ChatResponse(response=response)
-        
-    except Exception as e:
-        logger.error(f"Chat error: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Chat error: {str(e)}"
-        )
-
-# --------------- Knowledge Base Management ---------------
-URLS = [
-    "https://status.law",
-    "https://status.law/about",
-    "https://status.law/careers",  
-    "https://status.law/tariffs-for-services-against-extradition-en",
-    "https://status.law/challenging-sanctions",
-    "https://status.law/law-firm-contact-legal-protection"
-    "https://status.law/cross-border-banking-legal-issues", 
-    "https://status.law/extradition-defense", 
-    "https://status.law/international-prosecution-protection", 
-    "https://status.law/interpol-red-notice-removal",  
-    "https://status.law/practice-areas",  
-    "https://status.law/reputation-protection",
-    "https://status.law/faq"
-]
-
-def build_knowledge_base(_embeddings):
-    """Build or update the knowledge base"""
-    try:
-        start_time = time.time()
-        documents = []
-        
-        # Ensure vector store directory exists
-        if not os.path.exists(VECTOR_STORE_PATH):
-            os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
-        
-        for url in URLS:
-            try:
-                loader = WebBaseLoader(url)
-                docs = loader.load()
-                documents.extend(docs)
-            except Exception as e:
-                print(f"Failed to load {url}: {str(e)}")
-                continue
-
-        if not documents:
-            raise HTTPException(status_code=500, detail="No documents loaded")
-
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=500,
-            chunk_overlap=100
-        )
-        chunks = text_splitter.split_documents(documents)
-        
-        vector_store = FAISS.from_documents(chunks, _embeddings)
-        vector_store.save_local(
-            folder_path=VECTOR_STORE_PATH,
-            index_name="index"
-        )
-        
-        if not os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
-            raise HTTPException(status_code=500, detail="FAISS index file not created")
-            
-        return vector_store
-            
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Knowledge base creation failed: {str(e)}")
-
-# --------------- API Models ---------------
-class ChatRequest(BaseModel):
-    message: str
-
-class ChatResponse(BaseModel):
-    response: str
-
-# --------------- API Routes ---------------
-@app.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(request: ChatRequest):
-    try:
-        llm, embeddings = init_models()
-        
-        if not os.path.exists(VECTOR_STORE_PATH):
-            vector_store = build_knowledge_base(embeddings)
-        else:
-            vector_store = FAISS.load_local(
-                VECTOR_STORE_PATH,
-                embeddings,
-                allow_dangerous_deserialization=True
-            )
-
-        # Add retry logic for network operations
-        max_retries = 3
-        retry_count = 0
-        
-        while retry_count < max_retries:
-            try:
-                context_docs = vector_store.similarity_search(request.message)
-                context_text = "\n".join([d.page_content for d in context_docs])
-                
-                prompt_template = PromptTemplate.from_template('''
-                    You are a helpful and polite legal assistant at Status Law.
-                    You answer in the language in which the question was asked.
-                    Answer the question based on the context provided.
-                    
-                    # ... остальной текст промпта ...
-
-                    Context: {context}
-                    Question: {question}
-                    
-                    Response Guidelines:
-                    1. Answer in the user's language
-                    2. Cite sources when possible
-                    3. Offer contact options if unsure
-                    ''')
-                
-                chain = prompt_template | llm | StrOutputParser()
-                response = chain.invoke({
-                    "context": context_text,
-                    "question": request.message
-                })
-                
-                log_interaction(request.message, response, context_text)
-                return ChatResponse(response=response)
-                
-            except (requests.exceptions.RequestException, aiohttp.ClientError) as e:
-                retry_count += 1
-                if retry_count == max_retries:
-                    raise HTTPException(
-                        status_code=503,
-                        detail={
-                            "error": "Network error after maximum retries",
-                            "detail": str(e),
-                            "type": "network_error"
-                        }
-                    )
-                await asyncio.sleep(1 * retry_count)  # Exponential backoff
-                
-    except Exception as e:
-        if isinstance(e, (requests.exceptions.RequestException, aiohttp.ClientError)):
-            raise HTTPException(
-                status_code=503,
-                detail={
-                    "error": "Network error occurred",
-                    "detail": str(e),
-                    "type": "network_error"
-                }
-            )
-        raise HTTPException(status_code=500, detail=str(e))
-
-# --------------- Logging ---------------
-def log_interaction(user_input: str, bot_response: str, context: str):
-    try:
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "user_input": user_input,
-            "bot_response": bot_response,
-            "context": context[:500],
-            "kb_version": datetime.now().strftime("%Y%m%d-%H%M%S")
-        }
-        
-        os.makedirs("chat_history", exist_ok=True)
-        log_path = os.path.join("chat_history", "chat_logs.json")
-        
-        with open(log_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
-            
-    except Exception as e:
-        print(f"Logging error: {str(e)}")
-        print(traceback.format_exc())
-
-# Add health check endpoint
-@app.get("/health")
-async def health_check():
-    try:
-        # Check if models can be initialized
-        llm, embeddings = init_models()
-        
-        # Check if vector store is accessible
-        if os.path.exists(VECTOR_STORE_PATH):
-            vector_store = FAISS.load_local(
-                VECTOR_STORE_PATH,
-                embeddings,
-                allow_dangerous_deserialization=True
-            )
-        
-        return {
-            "status": "healthy",
-            "vector_store": "available" if os.path.exists(VECTOR_STORE_PATH) else "not_found"
-        }
-        
-    except Exception as e:
-        return JSONResponse(
-            status_code=503,
-            content={
-                "status": "unhealthy",
-                "error": str(e)
-            }
-        )
-
-# Add diagnostic endpoint
-@app.get("/directory-status")
-async def check_directory_status():
-    """Check status of required directories"""
-    return {
-        "vector_store": {
-            "exists": os.path.exists(VECTOR_STORE_PATH),
-            "path": os.path.abspath(VECTOR_STORE_PATH),
-            "contents": os.listdir(VECTOR_STORE_PATH) if os.path.exists(VECTOR_STORE_PATH) else []
-        },
-        "chat_history": {
-            "exists": os.path.exists(CHAT_HISTORY_PATH),
-            "path": os.path.abspath(CHAT_HISTORY_PATH),
-            "contents": os.listdir(CHAT_HISTORY_PATH) if os.path.exists(CHAT_HISTORY_PATH) else []
-        }
-    }
-
-# Добавим функцию для вывода статуса
-def print_startup_status():
-    """Print application startup status with rich formatting"""
-    try:
-        # Create status table
-        table = Table(show_header=True, header_style="bold magenta")
-        table.add_column("Component", style="cyan")
-        table.add_column("Status", style="green")
-        
-        # Check directories
-        vector_store_exists = os.path.exists(VECTOR_STORE_PATH)
-        chat_history_exists = os.path.exists(CHAT_HISTORY_PATH)
-        
-        table.add_row(
-            "Vector Store Directory",
-            "✅ Created" if vector_store_exists else "❌ Missing"
-        )
-        table.add_row(
-            "Chat History Directory",
-            "✅ Created" if chat_history_exists else "❌ Missing"
-        )
-        
-        # Check environment variables
-        table.add_row(
-            "GROQ API Key",
-            "✅ Set" if os.getenv("GROQ_API_KEY") else "❌ Missing"
-        )
-        
-        # Create status panel
-        status_panel = Panel(
-            table,
-            title="[bold blue]Status Law Assistant API Status[/bold blue]",
-            border_style="blue"
-        )
-        
-        # Print startup message and status
-        console.print("\n")
-        console.print("[bold green]🚀 Server started successfully![/bold green]")
-        console.print(status_panel)
-        console.print("\n[bold yellow]API Documentation:[/bold yellow]")
-        console.print("📚 Swagger UI: http://0.0.0.0:8000/docs")
-        console.print("📘 ReDoc: http://0.0.0.0:8000/redoc\n")
-        
-    except Exception as e:
-        console.print(f"[bold red]Error printing status: {str(e)}[/bold red]")
-
-if __name__ == "__main__":
-    import uvicorn
-    
-    port = int(os.getenv("PORT", 8000))
-    logger.info(f"Starting server on port {port}")
-    
-    config = uvicorn.Config(
-        app,
-        host="0.0.0.0",
-        port=port,
-        log_level="debug"
-    )
-    
-    server = uvicorn.Server(config)
-    server.run()

app.py

@@ -1,423 +1,80 @@
 import os
-
-# Установка переменных окружения для кэша HuggingFace
-#os.environ["TRANSFORMERS_CACHE"] = "cache/huggingface"
-os.environ["HF_HOME"] = "cache/huggingface"
-os.environ["HUGGINGFACE_HUB_CACHE"] = "cache/huggingface"
-os.environ["XDG_CACHE_HOME"] = "cache"
-
-# Создание необходимых директорий
-os.makedirs("cache/huggingface", exist_ok=True)
-
+import threading
 import time
+import gradio as gr
 import uvicorn
-from fastapi import FastAPI, HTTPException, Request
-from fastapi.middleware.cors import CORSMiddleware
+import requests
+from fastapi import FastAPI
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
-from dotenv import load_dotenv
-from langchain_groq import ChatGroq
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders import WebBaseLoader
-from langchain_core.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from datetime import datetime
-import json
-import traceback
-from typing import Dict, List, Optional
-from pydantic import BaseModel
-from huggingface_hub import Repository, snapshot_download
-
-# Initialize environment variables
-load_dotenv()
-
-# Constants for paths and URLs
-VECTOR_STORE_PATH = "vector_store"
-LOCAL_CHAT_HISTORY_PATH = "chat_history"
-DATA_SNAPSHOT_PATH = "data_snapshot"
-HF_DATASET_REPO = "Rulga/LS_chat"
-
-URLS = [
-    "https://status.law",
-    "https://status.law/about",
-    "https://status.law/careers",  
-    "https://status.law/tariffs-for-services-of-protection-against-extradition",
-    "https://status.law/challenging-sanctions",
-    "https://status.law/law-firm-contact-legal-protection", 
-    "https://status.law/cross-border-banking-legal-issues", 
-    "https://status.law/extradition-defense", 
-    "https://status.law/international-prosecution-protection", 
-    "https://status.law/interpol-red-notice-removal",  
-    "https://status.law/practice-areas",  
-    "https://status.law/reputation-protection",
-    "https://status.law/faq"
-]
-
-# Initialize the FastAPI app
-app = FastAPI(title="Status Law Assistant API")
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# Import our main application
+from fastapi_server import app as fastapi_app
 
-# Define request and response models
-class ChatRequest(BaseModel):
-    message: str
-    conversation_id: Optional[str] = None
-    
-class ChatResponse(BaseModel):
-    response: str
-    conversation_id: str
-    
-class BuildKnowledgeBaseResponse(BaseModel):
-    status: str
-    message: str
-    details: Optional[Dict] = None
+# Run FastAPI server in a separate thread
+def run_fastapi():
+    uvicorn.run(fastapi_app, host="0.0.0.0", port=8000)
 
-# Global variables for models and knowledge base
-llm = None
-embeddings = None
-vector_store = None
-kb_info = {
-    'build_time': None,
-    'size': None,
-    'version': '1.1'
-}
-
-# --------------- Hugging Face Dataset Integration ---------------
-def init_hf_dataset_integration():
-    """Initialize integration with Hugging Face dataset for persistence"""
-    try:
-        # Download the latest snapshot of the dataset if it exists
-        if os.getenv("HF_TOKEN"):
-            # With authentication if token provided
-            snapshot_download(
-                repo_id=HF_DATASET_REPO,
-                repo_type="dataset",
-                local_dir="./data_snapshot",
-                token=os.getenv("HF_TOKEN")
-            )
-        else:
-            # Try without authentication for public datasets
-            snapshot_download(
-                repo_id=HF_DATASET_REPO,
-                repo_type="dataset",
-                local_dir="./data_snapshot"
-            )
-        
-        # Check if vector store exists in the downloaded data
-        if os.path.exists("./data_snapshot/vector_store/index.faiss"):
-            # Copy to the local vector store path
-            os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
-            os.system(f"cp -r ./data_snapshot/vector_store/* {VECTOR_STORE_PATH}/")
-            return True
-    except Exception as e:
-        print(f"Error downloading dataset: {e}")
-    
-    return False
+# Start FastAPI in a background thread
+fastapi_thread = threading.Thread(target=run_fastapi, daemon=True)
+fastapi_thread.start()
 
-def upload_to_hf_dataset():
-    """Upload the vector store and chat history to the Hugging Face dataset"""
-    if not os.getenv("HF_TOKEN"):
-        print("HF_TOKEN not set, cannot upload to Hugging Face")
-        return False
-    
-    try:
-        # Clone the repository
-        repo = Repository(
-            local_dir="./data_upload",
-            clone_from=HF_DATASET_REPO,
-            repo_type="dataset",
-            token=os.getenv("HF_TOKEN")
-        )
-        
-        # Copy the vector store files
-        if os.path.exists(f"{VECTOR_STORE_PATH}/index.faiss"):
-            os.makedirs("./data_upload/vector_store", exist_ok=True)
-            os.system(f"cp -r {VECTOR_STORE_PATH}/* ./data_upload/vector_store/")
-        
-        # Copy the chat history
-        if os.path.exists(f"{LOCAL_CHAT_HISTORY_PATH}/chat_logs.json"):
-            os.makedirs("./data_upload/chat_history", exist_ok=True)
-            os.system(f"cp -r {LOCAL_CHAT_HISTORY_PATH}/* ./data_upload/chat_history/")
-        
-        # Push to Hugging Face
-        repo.push_to_hub(commit_message="Update vector store and chat history")
-        return True
-    except Exception as e:
-        print(f"Error uploading to dataset: {e}")
-        return False
-
-# --------------- Enhanced Logging ---------------
-def log_interaction(user_input: str, bot_response: str, context: str, conversation_id: str):
-    """Log interactions with error handling"""
-    try:
-        log_entry = {
-            "timestamp": datetime.now().isoformat(),
-            "conversation_id": conversation_id,
-            "user_input": user_input,
-            "bot_response": bot_response,
-            "context": context[:500] if context else "",
-            "kb_version": kb_info['version']
-        }
-        
-        os.makedirs(LOCAL_CHAT_HISTORY_PATH, exist_ok=True)
-        log_path = os.path.join(LOCAL_CHAT_HISTORY_PATH, "chat_logs.json")
-        
-        with open(log_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
-            
-        # Upload to Hugging Face after logging
-        upload_to_hf_dataset()
-            
-    except Exception as e:
-        print(f"Logging error: {str(e)}")
-        print(traceback.format_exc())
-
-# --------------- Model Initialization ---------------
-def init_models():
-    """Initialize AI models"""
-    global llm, embeddings
-    
-    if not llm:
-        try:
-            llm = ChatGroq(
-                model_name="llama-3.3-70b-versatile",
-                temperature=0.6,
-                api_key=os.getenv("GROQ_API_KEY")
-            )
-        except Exception as e:
-            print(f"LLM initialization failed: {str(e)}")
-            raise HTTPException(status_code=500, detail=f"LLM initialization failed: {str(e)}")
-    
-    if not embeddings:
-        try:
-            embeddings = HuggingFaceEmbeddings(
-                model_name="intfloat/multilingual-e5-large-instruct"
-            )
-        except Exception as e:
-            print(f"Embeddings initialization failed: {str(e)}")
-            raise HTTPException(status_code=500, detail=f"Embeddings initialization failed: {str(e)}")
-    
-    return llm, embeddings
+# Wait for FastAPI to start
+time.sleep(5)
 
-# --------------- Knowledge Base Management ---------------
-def build_knowledge_base():
-    """Build or update the knowledge base"""
-    global vector_store, kb_info
-    
-    _, _embeddings = init_models()
-    
+# Create a Gradio interface that will proxy requests to FastAPI
+def chat_with_api(message, conversation_id=None):
     try:
-        start_time = time.time()
-        documents = []
-        
-        # Create folder in advance
-        os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
-        
-        # Load documents
-        for url in URLS:
-            try:
-                loader = WebBaseLoader(url)
-                docs = loader.load()
-                documents.extend(docs)
-                print(f"Loaded {url}")
-            except Exception as e:
-                print(f"Failed to load {url}: {str(e)}")
-                continue
-                
-        if not documents:
-            raise HTTPException(status_code=500, detail="No documents loaded!")
-
-        # Split into chunks
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=500,
-            chunk_overlap=100
+        response = requests.post(
+            "http://127.0.0.1:8000/chat",
+            json={"message": message, "conversation_id": conversation_id}
         )
-        chunks = text_splitter.split_documents(documents)
-        
-        # Create vector store
-        vector_store = FAISS.from_documents(chunks, _embeddings)
-        vector_store.save_local(
-            folder_path=VECTOR_STORE_PATH,
-            index_name="index"
-        )
-        
-        # Verify file creation
-        if not os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
-            raise HTTPException(status_code=500, detail="FAISS index file not created!")
-            
-        # Update info
-        kb_info.update({
-            'build_time': time.time() - start_time,
-            'size': sum(
-                os.path.getsize(os.path.join(VECTOR_STORE_PATH, f)) 
-                for f in ["index.faiss", "index.pkl"]
-            ) / (1024 ** 2),
-            'version': datetime.now().strftime("%Y%m%d-%H%M%S")
-        })
-        
-        # Upload to Hugging Face
-        upload_to_hf_dataset()
-        
-        return {
-            "status": "success",
-            "message": "Knowledge base successfully created!",
-            "details": kb_info
-        }
-            
+        if response.status_code == 200:
+            data = response.json()
+            return data["response"], data["conversation_id"]
+        else:
+            return f"Error: {response.status_code} - {response.text}", conversation_id
     except Exception as e:
-        error_msg = f"Knowledge base creation failed: {str(e)}"
-        print(error_msg)
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=error_msg)
+        return f"API connection error: {str(e)}", conversation_id
 
-def load_knowledge_base():
-    """Load the knowledge base from disk"""
-    global vector_store
-    
-    if vector_store:
-        return vector_store
-        
-    _, _embeddings = init_models()
-    
+def build_kb():
     try:
-        vector_store = FAISS.load_local(
-            VECTOR_STORE_PATH,
-            _embeddings,
-            allow_dangerous_deserialization=True
-        )
-        return vector_store
+        response = requests.post("http://127.0.0.1:8000/build-kb")
+        if response.status_code == 200:
+            return f"Success: {response.json()['message']}"
+        else:
+            return f"Error: {response.status_code} - {response.text}"
     except Exception as e:
-        error_msg = f"Failed to load knowledge base: {str(e)}"
-        print(error_msg)
-        print(traceback.format_exc())
-        return None
+        return f"API connection error: {str(e)}"
 
-# --------------- API Endpoints ---------------
-@app.get("/")
-async def root():
-    """Root endpoint that shows app status"""
-    vector_store_exists = os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss"))
+# Create the Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Status Law Assistant")
     
-    return {
-        "status": "running",
-        "knowledge_base_exists": vector_store_exists,
-        "kb_info": kb_info if vector_store_exists else None
-    }
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy"}
-
-@app.post("/build-kb", response_model=BuildKnowledgeBaseResponse)
-async def build_kb_endpoint():
-    """Endpoint to build/rebuild the knowledge base"""
-    return build_knowledge_base()
-
-@app.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(request: ChatRequest):
-    """Endpoint to chat with the assistant"""
-    # Check if knowledge base exists
-    if not os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
-        raise HTTPException(
-            status_code=400, 
-            detail="Knowledge base not found. Please build it first with /build-kb"
-        )
+    with gr.Row():
+        with gr.Column():
+            build_kb_btn = gr.Button("Create/Update Knowledge Base")
+            kb_status = gr.Textbox(label="Knowledge Base Status")
+            build_kb_btn.click(build_kb, inputs=None, outputs=kb_status)
     
-    # Use provided conversation ID or generate a new one
-    conversation_id = request.conversation_id or f"conv_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    conversation_id = gr.State(None)
     
-    try:
-        # Load models and knowledge base
-        _llm, _ = init_models()
-        _vector_store = load_knowledge_base()
-        
-        if not _vector_store:
-            raise HTTPException(
-                status_code=500, 
-                detail="Failed to load knowledge base"
-            )
-        
-        # Retrieve context
-        context_docs = _vector_store.similarity_search(request.message)
-        context_text = "\n".join([d.page_content for d in context_docs])
-        
-        # Generate response
-        prompt_template = PromptTemplate.from_template('''
-            You are a helpful and polite legal assistant at Status Law.
-            You answer in the language in which the question was asked.
-            Answer the question based on the context provided.
-            If you cannot answer based on the context, say so politely and offer to contact Status Law directly via the following channels:
-            - For all users: +32465594521 (landline phone).
-            - For English and Swedish speakers only: +46728495129 (available on WhatsApp, Telegram, Signal, IMO).
-            - Provide a link to the contact form: [Contact Form](https://status.law/law-firm-contact-legal-protection/).
-            If the user has questions about specific services and their costs, suggest they visit the page https://status.law/tariffs-for-services-of-protection-against-extradition-and-international-prosecution/ for detailed information.
-
-            Ask the user additional questions to understand which service to recommend and provide an estimated cost. For example, clarify their situation and needs to suggest the most appropriate options.
-
-            Also, offer free consultations if they are available and suitable for the user's request.
-            Answer professionally but in a friendly manner.
-
-            Example:
-            Q: How can I challenge the sanctions?
-            A: To challenge the sanctions, you should consult with our legal team, who specialize in this area. Please contact us directly for detailed advice. You can fill out our contact form here: [Contact Form](https://status.law/law-firm-contact-legal-protection/).
-
-            Context: {context}
-            Question: {question}
+    with gr.Row():
+        with gr.Column():
+            chatbot = gr.Chatbot(label="Chat with Assistant")
+            msg = gr.Textbox(label="Your Question")
             
-            Response Guidelines:
-            1. Answer in the user's language
-            2. Cite sources when possible
-            3. Offer contact options if unsure
-            ''')
-        
-        chain = prompt_template | _llm | StrOutputParser()
-        response = chain.invoke({
-            "context": context_text,
-            "question": request.message
-        })
-        
-        # Log the interaction
-        log_interaction(request.message, response, context_text, conversation_id)
-        
-        return {
-            "response": response,
-            "conversation_id": conversation_id
-        }
+            def respond(message, chat_history, conv_id):
+                if not message.strip():
+                    return chat_history, conv_id
                 
-    except Exception as e:
-        error_msg = f"Error generating response: {str(e)}"
-        print(error_msg)
-        print(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=error_msg)
-
-# Initialize dataset integration at startup
-@app.on_event("startup")
-async def startup_event():
-    """Initialize on startup"""
-    # Try to load existing knowledge base from Hugging Face
-    init_hf_dataset_integration()
-    
-    # Preload embeddings model to reduce first-request latency
-    try:
-        global embeddings
-        if not embeddings:
-            embeddings = HuggingFaceEmbeddings(
-                model_name="intfloat/multilingual-e5-large-instruct"
-            )
-    except Exception as e:
-        print(f"Warning: Failed to preload embeddings: {e}")
+                chat_history.append([message, ""])
+                response, new_conv_id = chat_with_api(message, conv_id)
+                chat_history[-1][1] = response
+                return chat_history, new_conv_id
+            
+            msg.submit(respond, [msg, chatbot, conversation_id], [chatbot, conversation_id])
 
-# Run the application
 if __name__ == "__main__":
-    uvicorn.run("app:app", host="0.0.0.0", port=8000)
+    # Launch Gradio interface
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

fastapi_server.py

@@ -0,0 +1,432 @@
+import os
+
+# Установка переменных окружения для кэша HuggingFace
+#os.environ["TRANSFORMERS_CACHE"] = "cache/huggingface"
+os.environ["HF_HOME"] = "cache/huggingface"
+os.environ["HUGGINGFACE_HUB_CACHE"] = "cache/huggingface"
+os.environ["XDG_CACHE_HOME"] = "cache"
+
+# Создание необходимых директорий
+os.makedirs("cache/huggingface", exist_ok=True)
+
+import time
+import uvicorn
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from datetime import datetime
+import json
+import traceback
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+from huggingface_hub import Repository, snapshot_download
+
+# Initialize environment variables
+load_dotenv()
+
+# Constants for paths and URLs
+VECTOR_STORE_PATH = "vector_store"
+LOCAL_CHAT_HISTORY_PATH = "chat_history"
+DATA_SNAPSHOT_PATH = "data_snapshot"
+HF_DATASET_REPO = "Rulga/LS_chat"
+
+URLS = [
+    "https://status.law",
+    "https://status.law/about",
+    "https://status.law/careers",  
+    "https://status.law/tariffs-for-services-of-protection-against-extradition",
+    "https://status.law/challenging-sanctions",
+    "https://status.law/law-firm-contact-legal-protection", 
+    "https://status.law/cross-border-banking-legal-issues", 
+    "https://status.law/extradition-defense", 
+    "https://status.law/international-prosecution-protection", 
+    "https://status.law/interpol-red-notice-removal",  
+    "https://status.law/practice-areas",  
+    "https://status.law/reputation-protection",
+    "https://status.law/faq"
+]
+
+# Initialize the FastAPI app
+app = FastAPI(title="Status Law Assistant API")
+
+# Support for static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Web interface route
+@app.get("/web", response_class=HTMLResponse)
+async def web_interface():
+    with open("index.html", "r", encoding="utf-8") as f:
+        return HTMLResponse(content=f.read())
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Define request and response models
+class ChatRequest(BaseModel):
+    message: str
+    conversation_id: Optional[str] = None
+    
+class ChatResponse(BaseModel):
+    response: str
+    conversation_id: str
+    
+class BuildKnowledgeBaseResponse(BaseModel):
+    status: str
+    message: str
+    details: Optional[Dict] = None
+
+# Global variables for models and knowledge base
+llm = None
+embeddings = None
+vector_store = None
+kb_info = {
+    'build_time': None,
+    'size': None,
+    'version': '1.1'
+}
+
+# --------------- Hugging Face Dataset Integration ---------------
+def init_hf_dataset_integration():
+    """Initialize integration with Hugging Face dataset for persistence"""
+    try:
+        # Download the latest snapshot of the dataset if it exists
+        if os.getenv("HF_TOKEN"):
+            # With authentication if token provided
+            snapshot_download(
+                repo_id=HF_DATASET_REPO,
+                repo_type="dataset",
+                local_dir="./data_snapshot",
+                token=os.getenv("HF_TOKEN")
+            )
+        else:
+            # Try without authentication for public datasets
+            snapshot_download(
+                repo_id=HF_DATASET_REPO,
+                repo_type="dataset",
+                local_dir="./data_snapshot"
+            )
+        
+        # Check if vector store exists in the downloaded data
+        if os.path.exists("./data_snapshot/vector_store/index.faiss"):
+            # Copy to the local vector store path
+            os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
+            os.system(f"cp -r ./data_snapshot/vector_store/* {VECTOR_STORE_PATH}/")
+            return True
+    except Exception as e:
+        print(f"Error downloading dataset: {e}")
+    
+    return False
+
+def upload_to_hf_dataset():
+    """Upload the vector store and chat history to the Hugging Face dataset"""
+    if not os.getenv("HF_TOKEN"):
+        print("HF_TOKEN not set, cannot upload to Hugging Face")
+        return False
+    
+    try:
+        # Clone the repository
+        repo = Repository(
+            local_dir="./data_upload",
+            clone_from=HF_DATASET_REPO,
+            repo_type="dataset",
+            token=os.getenv("HF_TOKEN")
+        )
+        
+        # Copy the vector store files
+        if os.path.exists(f"{VECTOR_STORE_PATH}/index.faiss"):
+            os.makedirs("./data_upload/vector_store", exist_ok=True)
+            os.system(f"cp -r {VECTOR_STORE_PATH}/* ./data_upload/vector_store/")
+        
+        # Copy the chat history
+        if os.path.exists(f"{LOCAL_CHAT_HISTORY_PATH}/chat_logs.json"):
+            os.makedirs("./data_upload/chat_history", exist_ok=True)
+            os.system(f"cp -r {LOCAL_CHAT_HISTORY_PATH}/* ./data_upload/chat_history/")
+        
+        # Push to Hugging Face
+        repo.push_to_hub(commit_message="Update vector store and chat history")
+        return True
+    except Exception as e:
+        print(f"Error uploading to dataset: {e}")
+        return False
+
+# --------------- Enhanced Logging ---------------
+def log_interaction(user_input: str, bot_response: str, context: str, conversation_id: str):
+    """Log interactions with error handling"""
+    try:
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "conversation_id": conversation_id,
+            "user_input": user_input,
+            "bot_response": bot_response,
+            "context": context[:500] if context else "",
+            "kb_version": kb_info['version']
+        }
+        
+        os.makedirs(LOCAL_CHAT_HISTORY_PATH, exist_ok=True)
+        log_path = os.path.join(LOCAL_CHAT_HISTORY_PATH, "chat_logs.json")
+        
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
+            
+        # Upload to Hugging Face after logging
+        upload_to_hf_dataset()
+            
+    except Exception as e:
+        print(f"Logging error: {str(e)}")
+        print(traceback.format_exc())
+
+# --------------- Model Initialization ---------------
+def init_models():
+    """Initialize AI models"""
+    global llm, embeddings
+    
+    if not llm:
+        try:
+            llm = ChatGroq(
+                model_name="llama-3.3-70b-versatile",
+                temperature=0.6,
+                api_key=os.getenv("GROQ_API_KEY")
+            )
+        except Exception as e:
+            print(f"LLM initialization failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"LLM initialization failed: {str(e)}")
+    
+    if not embeddings:
+        try:
+            embeddings = HuggingFaceEmbeddings(
+                model_name="intfloat/multilingual-e5-large-instruct"
+            )
+        except Exception as e:
+            print(f"Embeddings initialization failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Embeddings initialization failed: {str(e)}")
+    
+    return llm, embeddings
+
+# --------------- Knowledge Base Management ---------------
+def build_knowledge_base():
+    """Build or update the knowledge base"""
+    global vector_store, kb_info
+    
+    _, _embeddings = init_models()
+    
+    try:
+        start_time = time.time()
+        documents = []
+        
+        # Create folder in advance
+        os.makedirs(VECTOR_STORE_PATH, exist_ok=True)
+        
+        # Load documents
+        for url in URLS:
+            try:
+                loader = WebBaseLoader(url)
+                docs = loader.load()
+                documents.extend(docs)
+                print(f"Loaded {url}")
+            except Exception as e:
+                print(f"Failed to load {url}: {str(e)}")
+                continue
+                
+        if not documents:
+            raise HTTPException(status_code=500, detail="No documents loaded!")
+
+        # Split into chunks
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500,
+            chunk_overlap=100
+        )
+        chunks = text_splitter.split_documents(documents)
+        
+        # Create vector store
+        vector_store = FAISS.from_documents(chunks, _embeddings)
+        vector_store.save_local(
+            folder_path=VECTOR_STORE_PATH,
+            index_name="index"
+        )
+        
+        # Verify file creation
+        if not os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
+            raise HTTPException(status_code=500, detail="FAISS index file not created!")
+            
+        # Update info
+        kb_info.update({
+            'build_time': time.time() - start_time,
+            'size': sum(
+                os.path.getsize(os.path.join(VECTOR_STORE_PATH, f)) 
+                for f in ["index.faiss", "index.pkl"]
+            ) / (1024 ** 2),
+            'version': datetime.now().strftime("%Y%m%d-%H%M%S")
+        })
+        
+        # Upload to Hugging Face
+        upload_to_hf_dataset()
+        
+        return {
+            "status": "success",
+            "message": "Knowledge base successfully created!",
+            "details": kb_info
+        }
+            
+    except Exception as e:
+        error_msg = f"Knowledge base creation failed: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=error_msg)
+
+def load_knowledge_base():
+    """Load the knowledge base from disk"""
+    global vector_store
+    
+    if vector_store:
+        return vector_store
+        
+    _, _embeddings = init_models()
+    
+    try:
+        vector_store = FAISS.load_local(
+            VECTOR_STORE_PATH,
+            _embeddings,
+            allow_dangerous_deserialization=True
+        )
+        return vector_store
+    except Exception as e:
+        error_msg = f"Failed to load knowledge base: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        return None
+
+# --------------- API Endpoints ---------------
+@app.get("/")
+async def root():
+    """Root endpoint that shows app status"""
+    vector_store_exists = os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss"))
+    
+    return {
+        "status": "running",
+        "knowledge_base_exists": vector_store_exists,
+        "kb_info": kb_info if vector_store_exists else None
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+
+@app.post("/build-kb", response_model=BuildKnowledgeBaseResponse)
+async def build_kb_endpoint():
+    """Endpoint to build/rebuild the knowledge base"""
+    return build_knowledge_base()
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    """Endpoint to chat with the assistant"""
+    # Check if knowledge base exists
+    if not os.path.exists(os.path.join(VECTOR_STORE_PATH, "index.faiss")):
+        raise HTTPException(
+            status_code=400, 
+            detail="Knowledge base not found. Please build it first with /build-kb"
+        )
+    
+    # Use provided conversation ID or generate a new one
+    conversation_id = request.conversation_id or f"conv_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    
+    try:
+        # Load models and knowledge base
+        _llm, _ = init_models()
+        _vector_store = load_knowledge_base()
+        
+        if not _vector_store:
+            raise HTTPException(
+                status_code=500, 
+                detail="Failed to load knowledge base"
+            )
+        
+        # Retrieve context
+        context_docs = _vector_store.similarity_search(request.message)
+        context_text = "\n".join([d.page_content for d in context_docs])
+        
+        # Generate response
+        prompt_template = PromptTemplate.from_template('''
+            You are a helpful and polite legal assistant at Status Law.
+            You answer in the language in which the question was asked.
+            Answer the question based on the context provided.
+            If you cannot answer based on the context, say so politely and offer to contact Status Law directly via the following channels:
+            - For all users: +32465594521 (landline phone).
+            - For English and Swedish speakers only: +46728495129 (available on WhatsApp, Telegram, Signal, IMO).
+            - Provide a link to the contact form: [Contact Form](https://status.law/law-firm-contact-legal-protection/).
+            If the user has questions about specific services and their costs, suggest they visit the page https://status.law/tariffs-for-services-of-protection-against-extradition-and-international-prosecution/ for detailed information.
+
+            Ask the user additional questions to understand which service to recommend and provide an estimated cost. For example, clarify their situation and needs to suggest the most appropriate options.
+
+            Also, offer free consultations if they are available and suitable for the user's request.
+            Answer professionally but in a friendly manner.
+
+            Example:
+            Q: How can I challenge the sanctions?
+            A: To challenge the sanctions, you should consult with our legal team, who specialize in this area. Please contact us directly for detailed advice. You can fill out our contact form here: [Contact Form](https://status.law/law-firm-contact-legal-protection/).
+
+            Context: {context}
+            Question: {question}
+            
+            Response Guidelines:
+            1. Answer in the user's language
+            2. Cite sources when possible
+            3. Offer contact options if unsure
+            ''')
+        
+        chain = prompt_template | _llm | StrOutputParser()
+        response = chain.invoke({
+            "context": context_text,
+            "question": request.message
+        })
+        
+        # Log the interaction
+        log_interaction(request.message, response, context_text, conversation_id)
+        
+        return {
+            "response": response,
+            "conversation_id": conversation_id
+        }
+                
+    except Exception as e:
+        error_msg = f"Error generating response: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=error_msg)
+
+# Initialize dataset integration at startup
+@app.on_event("startup")
+async def startup_event():
+    """Initialize on startup"""
+    # Try to load existing knowledge base from Hugging Face
+    init_hf_dataset_integration()
+    
+    # Preload embeddings model to reduce first-request latency
+    try:
+        global embeddings
+        if not embeddings:
+            embeddings = HuggingFaceEmbeddings(
+                model_name="intfloat/multilingual-e5-large-instruct"
+            )
+    except Exception as e:
+        print(f"Warning: Failed to preload embeddings: {e}")
+
+# Run the application
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=8000)

requirements.txt

@@ -1,5 +1,6 @@
 fastapi==0.109.2
 uvicorn==0.27.1
+gradio>=4.0.0
 langchain>=0.1.0
 langchain_groq>=0.1.0
 langchain_huggingface>=0.0.2
@@ -11,4 +12,5 @@ python-dotenv>=1.0.0
 huggingface_hub>=0.19.0
 jinja2>=3.0.0
 aiofiles>=0.8.0
-python-multipart>=0.0.6
+python-multipart>=0.0.6
+requests