Download main.py from pvanand/rag-chat: direct link, hf CLI and curl.
- Browser
- Download file 12.9 kB
-
https://huggingface.co/spaces/pvanand/rag-chat/resolve/main/main.py
- Command line
-
hf download hf://spaces/pvanand/rag-chat/main.py
-
curl -L -o main.py https://huggingface.co/spaces/pvanand/rag-chat/resolve/main/main.py
12.9 kB
| from fastapi import FastAPI, HTTPException, Header, Depends, BackgroundTasks, Query | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import StreamingResponse | |
| from pydantic import BaseModel, Field | |
| from typing import List, Optional, Dict, AsyncGenerator | |
| import json | |
| import os | |
| import logging | |
| from txtai.embeddings import Embeddings | |
| import pandas as pd | |
| import glob | |
| import uuid | |
| import httpx | |
| import asyncio | |
| import requests | |
| from datetime import datetime | |
| # Set up logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| app = FastAPI( | |
| title="Embeddings API", | |
| description="An API for creating and querying text embeddings indexes.", | |
| version="1.0.0" | |
| ) | |
| CHAT_AUTH_KEY = os.environ.get("CHAT_AUTH_KEY", "default_secret_key") | |
| # Enable CORS | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], # Allows all origins | |
| allow_credentials=True, | |
| allow_methods=["*"], # Allows all methods | |
| allow_headers=["*"], # Allows all headers | |
| ) | |
| embeddings = Embeddings({"path": "avsolatorio/GIST-all-MiniLM-L6-v2"}) | |
| class DocumentRequest(BaseModel): | |
| index_id: str = Field(..., description="Unique identifier for the index") | |
| documents: List[str] = Field(..., description="List of documents to be indexed") | |
| class QueryRequest(BaseModel): | |
| index_id: str = Field(..., description="Unique identifier for the index to query") | |
| query: str = Field(..., description="The search query") | |
| num_results: int = Field(..., description="Number of results to return", ge=1) | |
| def save_embeddings(index_id: str, document_list: List[str]): | |
| try: | |
| folder_path = f"/app/indexes/{index_id}" | |
| os.makedirs(folder_path, exist_ok=True) | |
| # Save embeddings | |
| embeddings.save(f"{folder_path}/embeddings") | |
| # Save document_list | |
| with open(f"{folder_path}/document_list.json", "w") as f: | |
| json.dump(document_list, f) | |
| logger.info(f"Embeddings and document list saved for index_id: {index_id}") | |
| except Exception as e: | |
| logger.error(f"Error saving embeddings for index_id {index_id}: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error saving embeddings: {str(e)}") | |
| def load_embeddings(index_id: str) -> List[str]: | |
| try: | |
| folder_path = f"/app/indexes/{index_id}" | |
| if not os.path.exists(folder_path): | |
| logger.error(f"Index not found for index_id: {index_id}") | |
| raise HTTPException(status_code=404, detail="Index not found") | |
| # Load embeddings | |
| embeddings.load(f"{folder_path}/embeddings") | |
| # Load document_list | |
| with open(f"{folder_path}/document_list.json", "r") as f: | |
| document_list = json.load(f) | |
| logger.info(f"Embeddings and document list loaded for index_id: {index_id}") | |
| return document_list | |
| except Exception as e: | |
| logger.error(f"Error loading embeddings for index_id {index_id}: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error loading embeddings: {str(e)}") | |
| async def create_index(request: DocumentRequest): | |
| """ | |
| Create a new index with the given documents. | |
| - **index_id**: Unique identifier for the index | |
| - **documents**: List of documents to be indexed | |
| """ | |
| try: | |
| document_list = [(i, text, None) for i, text in enumerate(request.documents)] | |
| embeddings.index(document_list) | |
| save_embeddings(request.index_id, request.documents) # Save the original documents | |
| logger.info(f"Index created successfully for index_id: {request.index_id}") | |
| return {"message": "Index created successfully"} | |
| except Exception as e: | |
| logger.error(f"Error creating index: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error creating index: {str(e)}") | |
| async def query_index(request: QueryRequest): | |
| """ | |
| Query an existing index with the given search query. | |
| - **index_id**: Unique identifier for the index to query | |
| - **query**: The search query | |
| - **num_results**: Number of results to return | |
| """ | |
| try: | |
| document_list = load_embeddings(request.index_id) | |
| results = embeddings.search(request.query, request.num_results) | |
| queried_texts = [document_list[idx[0]] for idx in results] | |
| logger.info(f"Query executed successfully for index_id: {request.index_id}") | |
| return {"queried_texts": queried_texts} | |
| except Exception as e: | |
| logger.error(f"Error querying index: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error querying index: {str(e)}") | |
| def process_csv_file(file_path): | |
| try: | |
| df = pd.read_csv(file_path) | |
| df_rows = df.apply(lambda row: ' '.join(row.values.astype(str)), axis=1) | |
| txtai_data = [(i, row, None) for i, row in enumerate(df_rows)] | |
| return txtai_data, df_rows.tolist() | |
| except Exception as e: | |
| logger.error(f"Error processing CSV file {file_path}: {str(e)}") | |
| return None, None | |
| def check_and_index_csv_files(): | |
| index_data_folder = "/app/index_data" | |
| if not os.path.exists(index_data_folder): | |
| logger.warning(f"index_data folder not found: {index_data_folder}") | |
| return | |
| csv_files = glob.glob(os.path.join(index_data_folder, "*.csv")) | |
| for csv_file in csv_files: | |
| index_id = os.path.splitext(os.path.basename(csv_file))[0] | |
| if not os.path.exists(f"/app/indexes/{index_id}"): | |
| logger.info(f"Processing CSV file: {csv_file}") | |
| txtai_data, documents = process_csv_file(csv_file) | |
| if txtai_data and documents: | |
| embeddings.index(txtai_data) | |
| save_embeddings(index_id, documents) | |
| logger.info(f"CSV file indexed successfully: {csv_file}") | |
| else: | |
| logger.warning(f"Failed to process CSV file: {csv_file}") | |
| else: | |
| logger.info(f"Index already exists for: {csv_file}") | |
| # ... [Previous code for DocumentRequest, QueryRequest, save_embeddings, load_embeddings, create_index, query_index, process_csv_file, check_and_index_csv_files remains the same] | |
| class ChatRequest(BaseModel): | |
| query: str = Field(..., description="The user's query") | |
| index_id: str = Field(..., description="Unique identifier for the index to query") | |
| conversation_id: Optional[str] = Field(None, description="Unique identifier for the conversation") | |
| model_id: str = Field(..., description="Identifier for the LLM model to use") | |
| user_id: str = Field(..., description="Unique identifier for the user") | |
| enable_followup: bool = Field(default=False, description="Flag to enable follow-up questions") | |
| def get_api_key(x_api_key: str = Header(...)) -> str: | |
| if x_api_key != CHAT_AUTH_KEY: | |
| raise HTTPException(status_code=403, detail="Invalid API key") | |
| return x_api_key | |
| def stream_llm_request(api_key: str, llm_request: dict, endpoint_url: str): | |
| """ | |
| Make a streaming request to the LLM service using requests. | |
| """ | |
| try: | |
| headers = { | |
| "accept": "text/event-stream", | |
| "X-API-Key": api_key, | |
| "Content-Type": "application/json" | |
| } | |
| with requests.post(endpoint_url, headers=headers, json=llm_request, stream=True) as response: | |
| if response.status_code != 200: | |
| raise HTTPException(status_code=response.status_code, detail="Error from LLM service") | |
| for chunk in response.iter_content(chunk_size=None, decode_unicode=True): | |
| if chunk: | |
| yield chunk | |
| except requests.RequestException as e: | |
| logger.error(f"HTTP error occurred while making LLM request: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"HTTP error occurred while making LLM request: {str(e)}") | |
| except Exception as e: | |
| logger.error(f"Unexpected error occurred while making LLM request: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Unexpected error occurred while making LLM request: {str(e)}") | |
| async def chat(request: ChatRequest, background_tasks: BackgroundTasks, api_key: str = Depends(get_api_key)): | |
| try: | |
| document_list = load_embeddings(request.index_id) | |
| search_results = embeddings.search(request.query, 6) | |
| context = "\n".join([document_list[idx[0]] for idx in search_results]) | |
| rag_prompt = f"Based on the following context, please answer the user's question:\n\nContext:\n{context}\n\nUser's question: {request.query}\n\nAnswer:" | |
| system_prompt = "You are a helpful assistant tasked with providing answers using the context provided" | |
| conversation_id = request.conversation_id or str(uuid.uuid4()) | |
| if request.enable_followup: | |
| llm_request = { | |
| "query": rag_prompt, | |
| "model_id": 'openai/gpt-4o-mini', | |
| "conversation_id": conversation_id, | |
| "user_id": request.user_id | |
| } | |
| endpoint_url = "https://pvanand-general-chat.hf.space/v2/followup-agent" | |
| else: | |
| llm_request = { | |
| "prompt": rag_prompt, | |
| "system_message": system_prompt, | |
| "model_id": request.model_id, | |
| "conversation_id": conversation_id, | |
| "user_id": request.user_id | |
| } | |
| endpoint_url = "https://pvanand-audio-chat.hf.space/llm-agent" | |
| logger.info(f"Starting chat response generation for user: {request.user_id} Full request: {llm_request}") | |
| def response_generator(): | |
| full_response = "" | |
| for chunk in stream_llm_request(api_key, llm_request, endpoint_url): | |
| full_response += chunk | |
| yield chunk | |
| logger.info(f"Finished chat response generation for user: {request.user_id} Full response: {full_response}") | |
| return StreamingResponse(response_generator(), media_type="text/event-stream") | |
| except Exception as e: | |
| logger.error(f"Error in chat endpoint: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error in chat endpoint: {str(e)}") | |
| from typing import Dict, List | |
| import os | |
| import json | |
| class IndexMetadata(BaseModel): | |
| index_id: str | |
| document_count: int | |
| created_at: str = Field(default_factory=lambda: datetime.now().isoformat()) | |
| size_bytes: int | |
| async def list_indexes(): | |
| """ | |
| List all available indexes and their metadata. | |
| Returns a dictionary containing: | |
| - List of indexes with their metadata (document count, creation date, size) | |
| """ | |
| try: | |
| indexes_path = "/app/indexes" | |
| if not os.path.exists(indexes_path): | |
| return {"indexes": []} | |
| indexes = [] | |
| for index_id in os.listdir(indexes_path): | |
| index_path = os.path.join(indexes_path, index_id) | |
| if os.path.isdir(index_path): | |
| try: | |
| # Get document count from document_list.json | |
| doc_list_path = os.path.join(index_path, "document_list.json") | |
| with open(doc_list_path, "r") as f: | |
| documents = json.load(f) | |
| doc_count = len(documents) | |
| # Calculate total size of the index | |
| total_size = 0 | |
| for root, dirs, files in os.walk(index_path): | |
| total_size += sum(os.path.getsize(os.path.join(root, file)) for file in files) | |
| # Get creation time of the index directory | |
| created_at = datetime.fromtimestamp(os.path.getctime(index_path)).isoformat() | |
| indexes.append(IndexMetadata( | |
| index_id=index_id, | |
| document_count=doc_count, | |
| created_at=created_at, | |
| size_bytes=total_size | |
| )) | |
| except Exception as e: | |
| logger.error(f"Error processing index {index_id}: {str(e)}") | |
| continue | |
| logger.info(f"Successfully retrieved metadata for {len(indexes)} indexes") | |
| return {"indexes": indexes} | |
| except Exception as e: | |
| logger.error(f"Error listing indexes: {str(e)}") | |
| raise HTTPException(status_code=500, detail=f"Error listing indexes: {str(e)}") | |
| async def startup_event(): | |
| check_and_index_csv_files() | |
| if __name__ == "__main__": | |
| import uvicorn | |
| uvicorn.run(app, host="0.0.0.0", port=7860) |