Initial commit.

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.venv

Dockerfile

@@ -0,0 +1,27 @@
+# Use the official Python 3.9 image
+FROM python:3.9
+
+# Set the working directory to /code
+WORKDIR /code
+
+# Copy the current directory contents into the container at /code
+COPY ./requirements.txt /code/requirements.txt
+
+# Install requirements.txt 
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+# Switch to the "user" user
+USER user
+# Set home to the user's home directory
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app setting the owner to the user
+COPY --chown=user . $HOME/app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,194 @@
+---
+title: Al Ghazali Rag Retrieval Api
+emoji: 🔗
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+license: unknown
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Al Ghazali Rag Retrieval Api
+
+## Endpoints
+
+### 1. `/login` Endpoint
+This endpoint is used to authenticate the user and issue an access token and a refresh token.
+
+#### Request:
+```bash
+curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login \
+     -H "Content-Type: application/x-www-form-urlencoded" \
+     -d 'username=user1332&password=RmzmurS7aE!t'
+```
+
+#### Response:
+If the credentials are valid, the server responds with:
+```json
+{
+    "access_token": "your-access-token",
+    "refresh_token": "your-refresh-token",
+    "token_type": "bearer",
+    "expires_in": 1800  // Access token expires in 30 minutes (1800 seconds)
+}
+```
+
+If the credentials are invalid, the server responds with:
+```json
+{
+    "detail": "Invalid username or password"
+}
+```
+
+### 2. `/refresh` Endpoint
+This endpoint is used to refresh the access token using a valid refresh token.
+
+#### Request:
+```bash
+curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh \
+     -H "Content-Type: application/json" \
+     -d '{"refresh_token": "your-refresh-token"}'
+```
+
+#### Response:
+If the refresh token is valid, the server responds with:
+```json
+{
+    "access_token": "new-access-token",
+    "refresh_token": "your-refresh-token",  // Optionally issue a new refresh token
+    "token_type": "bearer",
+    "expires_in": 1800
+}
+```
+
+If the refresh token is invalid or expired, the server responds with:
+```json
+{
+    "detail": "Could not validate credentials"
+}
+```
+
+### 3. `/search` Endpoint
+This endpoint is used to send a search query and retrieve results. It requires a valid access token.
+
+#### Request:
+```bash
+curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search \
+     -H "Content-Type: application/json" \
+     -H "Authorization: Bearer your-access-token" \
+     -d '{"query": "test query"}'
+```
+
+#### Response:
+If the access token is valid, the server responds with:
+```json
+[
+    {
+        "text": "Result 1 text",
+        "similarity": 0.95
+    },
+    {
+        "text": "Result 2 text",
+        "similarity": 0.92
+    },
+    {
+        "text": "Result 3 text",
+        "similarity": 0.89
+    }
+]
+```
+
+If the access token is invalid or expired, the server responds with:
+```json
+{
+    "detail": "Could not validate credentials"
+}
+```
+
+### 4. Root Endpoint (`/`)
+This endpoint is used to check if the API is running.
+
+#### Request:
+```bash
+curl -X GET https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/
+```
+
+#### Response:
+```json
+{
+    "message": "Welcome to the Alchemy of Happiness API!"
+}
+```
+
+## Workflow Example
+
+### Step 1: Login
+1. **Request**:
+   ```bash
+   curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login \
+        -H "Content-Type: application/x-www-form-urlencoded" \
+        -d 'username=user1332&password=RmzmurS7aE!t'
+   ```
+2. **Response**:
+   ```json
+   {
+       "access_token": "your-access-token",
+       "refresh_token": "your-refresh-token",
+       "token_type": "bearer",
+       "expires_in": 1800
+   }
+   ```
+
+### Step 2: Search
+1. **Request**:
+   ```bash
+   curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search \
+        -H "Content-Type: application/json" \
+        -H "Authorization: Bearer your-access-token" \
+        -d '{"query": "test query"}'
+   ```
+2. **Response**:
+   ```json
+   [
+       {
+           "text": "Result 1 text",
+           "similarity": 0.95
+       },
+       {
+           "text": "Result 2 text",
+           "similarity": 0.92
+       },
+       {
+           "text": "Result 3 text",
+           "similarity": 0.89
+       }
+   ]
+   ```
+
+### Step 3: Refresh Token
+1. **Request**:
+   ```bash
+   curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh \
+        -H "Content-Type: application/json" \
+        -d '{"refresh_token": "your-refresh-token"}'
+   ```
+2. **Response**:
+   ```json
+   {
+       "access_token": "new-access-token",
+       "refresh_token": "your-refresh-token",
+       "token_type": "bearer",
+       "expires_in": 1800
+   }
+   ```
+
+## Summary
+- **`/login`**: Authenticate and get tokens.
+- **`/refresh`**: Refresh the access token.
+- **`/search`**: Send a search query (requires a valid access token).
+- **`/`**: Check if the API is running.
+
+Let me know if you need further clarification or assistance!

[openai_embedded] The Alchemy of Happiness (Ghazzālī, Claud Field) (Z-Library).parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f94d381f4dfcff0bbf6bfa5c84def47794d1596e12e2204a2a4bb413fc25a05
+size 2257769

main.py

@@ -0,0 +1,181 @@
+from fastapi import FastAPI, HTTPException, Depends, status
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from openai import OpenAI
+from typing import List
+import pandas as pd
+import os
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+# Initialize FastAPI app
+app = FastAPI()
+
+# JWT Configuration
+SECRET_KEY = os.environ.get("prime_auth", "c0369f977b69e717dc16f6fc574039eb2b1ebde38014d2be")
+REFRESH_SECRET_KEY = os.environ.get("prolonged_auth", "916018771b29084378c9362c0cd9e631fd4927b8aea07f91")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+REFRESH_TOKEN_EXPIRE_DAYS = 7
+
+# OAuth2 scheme for token authentication
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+# Load credentials from environment variables
+def load_credentials():
+    credentials = {}
+    for i in range(1, 51):  # Assuming you have 50 credentials
+        username = os.environ.get(f"login_{i}")
+        password = os.environ.get(f"password_{i}")
+        if username and password:
+            credentials[username] = password
+    return credentials
+
+# Authenticate user and create token
+def authenticate_user(username: str, password: str):
+    credentials_dict = load_credentials()
+    if username in credentials_dict and credentials_dict[username] == password:
+        return username
+    return None
+
+# Create JWT token
+def create_token(data: dict, expires_delta: timedelta, secret_key: str):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + expires_delta
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, secret_key, algorithm=ALGORITHM)
+    return encoded_jwt
+
+# Verify JWT token
+def verify_token(token: str, secret_key: str):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, secret_key, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    return username
+
+# Verify access token
+def verify_access_token(token: str = Depends(oauth2_scheme)):
+    return verify_token(token, SECRET_KEY)
+
+# Verify refresh token
+def verify_refresh_token(token: str):
+    return verify_token(token, REFRESH_SECRET_KEY)
+
+# Load data from parquet file
+def load_data(database_file):
+    df = pd.read_parquet(database_file)
+
+    return df
+
+# Generate OpenAI embeddings
+def generate_openai_embeddings(client, text):
+    response = client.embeddings.create(
+        input=text,
+        model="text-embedding-3-small"
+    )
+    return response.data[0].embedding
+
+# Compute cosine similarity
+def cosine_similarity(embedding_0, embedding_1):
+    dot_product = sum(a * b for a, b in zip(embedding_0, embedding_1))
+    norm_0 = sum(a * a for a in embedding_0) ** 0.5
+    norm_1 = sum(b * b for b in embedding_1) ** 0.5
+    return dot_product / (norm_0 * norm_1)
+
+# Search query
+def search_query(client, query, df, n=3):
+    embedding = generate_openai_embeddings(client, query)
+    df['similarities'] = df.openai_embedding.apply(lambda x: cosine_similarity(x, embedding))
+    res = df.sort_values('similarities', ascending=False).head(n)
+    return res
+
+# Pydantic model for the query input
+class QueryInput(BaseModel):
+    query: str
+
+# Pydantic model for the search result
+class SearchResult(BaseModel):
+    text: str
+    similarity: float
+
+# Pydantic model for the token response
+class TokenResponse(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str
+
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
+
+# Root endpoint
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(path="/app/static/index.html", media_type="text/html")
+
+# Login endpoint to issue tokens
+@app.post("/login", response_model=TokenResponse)
+def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    username = authenticate_user(form_data.username, form_data.password)
+    if not username:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    refresh_token_expires = timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
+    access_token = create_token(data={"sub": username}, expires_delta=access_token_expires, secret_key=SECRET_KEY)
+    refresh_token = create_token(data={"sub": username}, expires_delta=refresh_token_expires, secret_key=REFRESH_SECRET_KEY)
+    return {"access_token": access_token, "refresh_token": refresh_token, "token_type": "bearer"}
+
+# Refresh token endpoint
+@app.post("/refresh", response_model=TokenResponse)
+def refresh(refresh_token: str):
+    username = verify_refresh_token(refresh_token)
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_token(data={"sub": username}, expires_delta=access_token_expires, secret_key=SECRET_KEY)
+    return {"access_token": access_token, "refresh_token": refresh_token, "token_type": "bearer"}
+
+# Search endpoint
+@app.post("/search", response_model=List[SearchResult])
+def search(
+    query_input: QueryInput,
+    username: str = Depends(verify_access_token),
+):
+    # Initialize OpenAI client
+    client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
+
+    # Load database
+    database_file = "/app/[openai_embedded] The Alchemy of Happiness (Ghazzālī, Claud Field) (Z-Library).parquet"
+    df = load_data(database_file)
+    logging.info("Database loaded successfully")
+
+    # Perform search
+    res = search_query(client, query_input.query, df, n=3)
+
+    # Format results
+    results = [
+        SearchResult(text=row["ext"], similarity=row["similarities"])
+        for _, row in res.iterrows()
+    ]
+
+    return results
+
+# Run the app
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+pandas
+openai
+python-dotenv
+python-jose[cryptography]
+python-multipart

static/index.html

@@ -0,0 +1,480 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Al Ghazali RAG API Documentation</title>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/prismjs/1.29.0/themes/prism-tomorrow.min.css" rel="stylesheet" />
+    <link href="style.css" rel="stylesheet" />
+</head>
+<body>
+    <div class="container">
+        <nav class="sidebar">
+            <div class="logo">
+                🔗 Al Ghazali RAG API
+            </div>
+            <div class="nav-items">
+                <!-- Navigation items will be populated by JavaScript -->
+            </div>
+        </nav>
+        <main class="content">
+            <h1>Al Ghazali RAG Retrieval API</h1>
+            
+            <section id="endpoints">
+                <h2>Endpoints</h2>
+                
+                <div class="endpoint" id="login">
+                    <h3>1. Login Endpoint</h3>
+                    <p><span class="method">POST</span><span class="endpoint-url">/login</span></p>
+                    <p>This endpoint is used to authenticate the user and issue an access token and a refresh token.</p>
+                    
+                    <h4>cURL Request:</h4>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login \
+     -H "Content-Type: application/x-www-form-urlencoded" \
+     -d 'username=user123&password=password123'</code></pre>
+
+                    <h4>Flutter Implementation:</h4>
+                    <pre><code class="language-dart">Future<LoginResponse> login(String username, String password) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login');
+  
+  try {
+    final response = await http.post(
+      url,
+      headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+      body: {
+        'username': username,
+        'password': password,
+      },
+    );
+
+    if (response.statusCode == 200) {
+      return LoginResponse.fromJson(jsonDecode(response.body));
+    } else {
+      throw Exception('Failed to login: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}
+
+// Model class
+class LoginResponse {
+  final String accessToken;
+  final String refreshToken;
+  final String tokenType;
+  final int expiresIn;
+
+  LoginResponse({
+    required this.accessToken,
+    required this.refreshToken,
+    required this.tokenType,
+    required this.expiresIn,
+  });
+
+  factory LoginResponse.fromJson(Map<String, dynamic> json) {
+    return LoginResponse(
+      accessToken: json['access_token'],
+      refreshToken: json['refresh_token'],
+      tokenType: json['token_type'],
+      expiresIn: json['expires_in'],
+    );
+  }
+}</code></pre>
+                    
+                    <h4>Response:</h4>
+                    <pre><code class="language-json">{
+    "access_token": "your-access-token",
+    "refresh_token": "your-refresh-token",
+    "token_type": "bearer",
+    "expires_in": 1800
+}</code></pre>
+                </div>
+
+                <div class="endpoint" id="refresh">
+                    <h3>2. Refresh Token Endpoint</h3>
+                    <p><span class="method">POST</span><span class="endpoint-url">/refresh</span></p>
+                    <p>This endpoint is used to refresh the access token using a valid refresh token.</p>
+                    
+                    <h4>cURL Request:</h4>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh \
+     -H "Content-Type: application/json" \
+     -d '{"refresh_token": "your-refresh-token"}'</code></pre>
+
+                    <h4>Flutter Implementation:</h4>
+                    <pre><code class="language-dart">Future<LoginResponse> refreshToken(String refreshToken) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh');
+  
+  try {
+    final response = await http.post(
+      url,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode({
+        'refresh_token': refreshToken,
+      }),
+    );
+
+    if (response.statusCode == 200) {
+      return LoginResponse.fromJson(jsonDecode(response.body));
+    } else {
+      throw Exception('Failed to refresh token: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}</code></pre>
+                    
+                    <h4>Response:</h4>
+                    <pre><code class="language-json">{
+    "access_token": "new-access-token",
+    "refresh_token": "your-refresh-token",
+    "token_type": "bearer",
+    "expires_in": 1800
+}</code></pre>
+                </div>
+
+                <div class="endpoint" id="search">
+                    <h3>3. Search Endpoint</h3>
+                    <p><span class="method">POST</span><span class="endpoint-url">/search</span></p>
+                    <p>This endpoint is used to send a search query and retrieve results. It requires a valid access token.</p>
+                    
+                    <h4>cURL Request:</h4>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search \
+     -H "Content-Type: application/json" \
+     -H "Authorization: Bearer your-access-token" \
+     -d '{"query": "test query"}'</code></pre>
+
+                    <h4>Flutter Implementation:</h4>
+                    <pre><code class="language-dart">class SearchResult {
+  final String text;
+  final double similarity;
+
+  SearchResult({
+    required this.text,
+    required this.similarity,
+  });
+
+  factory SearchResult.fromJson(Map<String, dynamic> json) {
+    return SearchResult(
+      text: json['text'],
+      similarity: json['similarity'].toDouble(),
+    );
+  }
+}
+
+Future<List<SearchResult>> search(String query, String accessToken) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search');
+  
+  try {
+    final response = await http.post(
+      url,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer $accessToken',
+      },
+      body: jsonEncode({
+        'query': query,
+      }),
+    );
+
+    if (response.statusCode == 200) {
+      List<dynamic> jsonList = jsonDecode(response.body);
+      return jsonList.map((json) => SearchResult.fromJson(json)).toList();
+    } else {
+      throw Exception('Search failed: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}</code></pre>
+                    
+                    <h4>Response:</h4>
+                    <pre><code class="language-json">[
+    {
+        "text": "Result 1 text",
+        "similarity": 0.95
+    },
+    {
+        "text": "Result 2 text",
+        "similarity": 0.92
+    },
+    {
+        "text": "Result 3 text",
+        "similarity": 0.89
+    }
+]</code></pre>
+                </div>
+            </section>
+
+            <section id="workflow">
+                <h2>Workflow Example</h2>
+                <p>Here's a complete workflow demonstrating how to use the API:</p>
+                
+                <h3>cURL Implementation</h3>
+                <div class="endpoint">
+                    <h3>Step 1: Login</h3>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login \
+     -H "Content-Type: application/x-www-form-urlencoded" \
+     -d 'username=user123&password=password123'</code></pre>
+                </div>
+
+                <div class="endpoint">
+                    <h3>Step 2: Search</h3>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search \
+     -H "Content-Type: application/json" \
+     -H "Authorization: Bearer your-access-token" \
+     -d '{"query": "test query"}'</code></pre>
+                </div>
+
+                <div class="endpoint">
+                    <h3>Step 3: Refresh Token</h3>
+                    <pre><code class="language-bash">curl -X POST https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh \
+     -H "Content-Type: application/json" \
+     -d '{"refresh_token": "your-refresh-token"}'</code></pre>
+                </div>
+
+                <h3>Flutter Implementation</h3>
+                <div class="endpoint">
+                    <h4>Complete Flutter Example</h4>
+                    <pre><code class="language-dart">import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+
+void main() {
+  runApp(MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'Al Ghazali RAG API Example',
+      home: ApiWorkflowExample(),
+    );
+  }
+}
+
+class ApiWorkflowExample extends StatefulWidget {
+  @override
+  _ApiWorkflowExampleState createState() => _ApiWorkflowExampleState();
+}
+
+class _ApiWorkflowExampleState extends State<ApiWorkflowExample> {
+  String _accessToken = '';
+  String _refreshToken = '';
+  List<SearchResult> _searchResults = [];
+
+  Future<void> _login() async {
+    final username = 'user123';
+    final password = 'password123';
+
+    try {
+      final loginResponse = await login(username, password);
+      setState(() {
+        _accessToken = loginResponse.accessToken;
+        _refreshToken = loginResponse.refreshToken;
+      });
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Login successful!')),
+      );
+    } catch (e) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Login failed: $e')),
+      );
+    }
+  }
+
+  Future<void> _search() async {
+    final query = 'test query';
+
+    try {
+      final results = await search(query, _accessToken);
+      setState(() {
+        _searchResults = results;
+      });
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Search successful!')),
+      );
+    } catch (e) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Search failed: $e')),
+      );
+    }
+  }
+
+  Future<void> _refreshToken() async {
+    try {
+      final loginResponse = await refreshToken(_refreshToken);
+      setState(() {
+        _accessToken = loginResponse.accessToken;
+      });
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Token refreshed successfully!')),
+      );
+    } catch (e) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('Token refresh failed: $e')),
+      );
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        title: Text('Al Ghazali RAG API Workflow'),
+      ),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            ElevatedButton(
+              onPressed: _login,
+              child: Text('Login'),
+            ),
+            ElevatedButton(
+              onPressed: _search,
+              child: Text('Search'),
+            ),
+            ElevatedButton(
+              onPressed: _refreshToken,
+              child: Text('Refresh Token'),
+            ),
+            Expanded(
+              child: ListView.builder(
+                itemCount: _searchResults.length,
+                itemBuilder: (context, index) {
+                  final result = _searchResults[index];
+                  return ListTile(
+                    title: Text(result.text),
+                    subtitle: Text('Similarity: ${result.similarity}'),
+                  );
+                },
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+Future<LoginResponse> login(String username, String password) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/login');
+
+  try {
+    final response = await http.post(
+      url,
+      headers: {'Content-Type': 'application/x-www-form-urlencoded'},
+      body: {
+        'username': username,
+        'password': password,
+      },
+    );
+
+    if (response.statusCode == 200) {
+      return LoginResponse.fromJson(jsonDecode(response.body));
+    } else {
+      throw Exception('Failed to login: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}
+
+Future<LoginResponse> refreshToken(String refreshToken) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/refresh');
+
+  try {
+    final response = await http.post(
+      url,
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode({
+        'refresh_token': refreshToken,
+      }),
+    );
+
+    if (response.statusCode == 200) {
+      return LoginResponse.fromJson(jsonDecode(response.body));
+    } else {
+      throw Exception('Failed to refresh token: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}
+
+Future<List<SearchResult>> search(String query, String accessToken) async {
+  final url = Uri.parse('https://humblebeeai-al-ghazali-rag-retrieval-api.hf.space/search');
+
+  try {
+    final response = await http.post(
+      url,
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer $accessToken',
+      },
+      body: jsonEncode({
+        'query': query,
+      }),
+    );
+
+    if (response.statusCode == 200) {
+      List<dynamic> jsonList = jsonDecode(response.body);
+      return jsonList.map((json) => SearchResult.fromJson(json)).toList();
+    } else {
+      throw Exception('Search failed: ${response.body}');
+    }
+  } catch (e) {
+    throw Exception('Network error: $e');
+  }
+}
+
+class LoginResponse {
+  final String accessToken;
+  final String refreshToken;
+  final String tokenType;
+  final int expiresIn;
+
+  LoginResponse({
+    required this.accessToken,
+    required this.refreshToken,
+    required this.tokenType,
+    required this.expiresIn,
+  });
+
+  factory LoginResponse.fromJson(Map<String, dynamic> json) {
+    return LoginResponse(
+      accessToken: json['access_token'],
+      refreshToken: json['refresh_token'],
+      tokenType: json['token_type'],
+      expiresIn: json['expires_in'],
+    );
+  }
+}
+
+class SearchResult {
+  final String text;
+  final double similarity;
+
+  SearchResult({
+    required this.text,
+    required this.similarity,
+  });
+
+  factory SearchResult.fromJson(Map<String, dynamic> json) {
+    return SearchResult(
+      text: json['text'],
+      similarity: json['similarity'].toDouble(),
+    );
+  }
+}
+        </main>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prismjs/1.29.0/prism.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prismjs/1.29.0/components/prism-bash.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/prismjs/1.29.0/components/prism-json.min.js"></script>
+    <script src="script.js"></script>
+</body>
+</html>

static/script.js

@@ -0,0 +1,43 @@
+// Generate navigation items
+const sections = [
+    { id: 'endpoints', title: 'Endpoints' },
+    { id: 'login', title: 'Login' },
+    { id: 'refresh', title: 'Refresh Token' },
+    { id: 'search', title: 'Search' },
+    { id: 'workflow', title: 'Workflow Example' }
+];
+
+const navItems = document.querySelector('.nav-items');
+sections.forEach(section => {
+    const item = document.createElement('div');
+    item.className = 'nav-item';
+    item.textContent = section.title;
+    item.setAttribute('data-section', section.id);
+    item.addEventListener('click', () => {
+        document.getElementById(section.id).scrollIntoView({ behavior: 'smooth' });
+    });
+    navItems.appendChild(item);
+});
+
+// Highlight current section in navigation
+const observerCallback = (entries) => {
+    entries.forEach(entry => {
+        if (entry.isIntersecting) {
+            const currentNav = document.querySelector(`.nav-item[data-section="${entry.target.id}"]`);
+            if (currentNav) {
+                document.querySelectorAll('.nav-item').forEach(item => {
+                    item.style.backgroundColor = '';
+                });
+                currentNav.style.backgroundColor = '#f3f4f6';
+            }
+        }
+    });
+};
+
+const observer = new IntersectionObserver(observerCallback, {
+    threshold: 0.2
+});
+
+document.querySelectorAll('section').forEach(section => {
+    observer.observe(section);
+});

static/style.css

@@ -0,0 +1,172 @@
+:root {
+    --primary-color: #4f46e5;
+    --secondary-color: #1e40af;
+    --text-color: #1f2937;
+    --code-bg: #1e1e1e;
+    --border-color: #e5e7eb;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    background-color: #f9fafb;
+}
+
+.container {
+    display: flex;
+    min-height: 100vh;
+}
+
+.sidebar {
+    width: 280px;
+    background-color: white;
+    border-right: 1px solid var(--border-color);
+    padding: 2rem;
+    position: fixed;
+    height: 100vh;
+    overflow-y: auto;
+}
+
+.content {
+    flex: 1;
+    padding: 2rem;
+    margin-left: 280px;
+    max-width: 1200px;
+}
+
+.logo {
+    font-size: 1.5rem;
+    font-weight: bold;
+    color: var(--primary-color);
+    margin-bottom: 2rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.nav-item {
+    margin: 0.5rem 0;
+    cursor: pointer;
+    padding: 0.5rem;
+    border-radius: 0.375rem;
+    transition: background-color 0.2s;
+}
+
+.nav-item:hover {
+    background-color: #f3f4f6;
+}
+
+h1 {
+    font-size: 2.5rem;
+    margin-bottom: 1.5rem;
+    color: var(--primary-color);
+}
+
+h2 {
+    font-size: 1.8rem;
+    margin: 2rem 0 1rem;
+    padding-top: 2rem;
+    border-top: 1px solid var(--border-color);
+}
+
+h3 {
+    font-size: 1.4rem;
+    margin: 1.5rem 0 1rem;
+    color: var(--secondary-color);
+}
+
+p {
+    margin-bottom: 1rem;
+}
+
+pre {
+    margin: 1rem 0;
+    padding: 1rem;
+    border-radius: 0.5rem;
+    background-color: #2d2d2d !important;
+    overflow-x: auto;
+    border: 1px solid #3f3f3f;
+}
+
+code {
+    font-family: 'Fira Code', monospace;
+    font-size: 0.9rem;
+    color: #e6e6e6;
+}
+
+/* Specific syntax highlighting overrides */
+.language-bash {
+    color: #e6e6e6 !important;
+}
+
+.language-bash .token.function {
+    color: #87ceeb !important;
+}
+
+.language-bash .token.operator {
+    color: #87ceeb !important;
+}
+
+.language-bash .token.string {
+    color: #98c379 !important;
+}
+
+.language-json {
+    color: #e6e6e6 !important;
+}
+
+.language-json .token.property {
+    color: #87ceeb !important;
+}
+
+.language-json .token.string {
+    color: #98c379 !important;
+}
+
+.language-json .token.number {
+    color: #d19a66 !important;
+}
+
+/* Add a subtle glow effect to code blocks */
+pre code {
+    text-shadow: 0 1px 1px rgba(0, 0, 0, 0.1);
+}
+
+.endpoint {
+    background-color: white;
+    border: 1px solid var(--border-color);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    margin: 1.5rem 0;
+}
+
+.method {
+    display: inline-block;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.25rem;
+    background-color: var(--primary-color);
+    color: white;
+    font-weight: 500;
+    margin-right: 0.5rem;
+}
+
+.endpoint-url {
+    font-family: 'Fira Code', monospace;
+    color: var(--secondary-color);
+}
+
+@media (max-width: 768px) {
+    .sidebar {
+        display: none;
+    }
+    .content {
+        margin-left: 0;
+    }
+}