streaming updated

main.py

@@ -1,10 +1,10 @@
-from fastapi import FastAPI, Depends, HTTPException, status
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi import FastAPI, Depends, HTTPException, status, Query
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from jose import JWTError
 from schemas import UserRegister, TokenResponse, RefreshTokenRequest, QueryInput
 from auth import  register_user, get_db, authenticate_user, create_token, verify_token, verify_access_token, Session
-from utils import generate_stream
+from utils import generate_stream, generate_response
 from fastapi.security import OAuth2PasswordRequestForm
 from pathlib import Path
 from datetime import timedelta
@@ -97,13 +97,17 @@ async def refresh(refresh_request: RefreshTokenRequest):
             headers={"WWW-Authenticate": "Bearer"},
         )
     
-@app.post("/search")
-async def search(
+@app.post("/generate")
+async def generate(
     query_input: QueryInput,
     username: str = Depends(verify_access_token),
+    stream: bool = Query(False, description="Enable streaming response"),
 ):
-    return StreamingResponse(generate_stream(query_input.query), media_type="text/plain")
-
+    """API endpoint that supports both streaming and non-streaming responses."""
+    if stream:
+        return StreamingResponse(generate_stream(query_input.query), media_type="text/event-stream")
+    else:
+        return JSONResponse(await generate_response(query_input.query))
 # WebSocket endpoint for streaming
 @app.on_event("startup")
 async def startup_event():

static/index.html

@@ -22,261 +22,84 @@
             
         <section id="endpoints">
             <h2>Endpoints</h2>
-                
-              <div class="endpoint" id="register">
-                    <h3>1. Register Endpoint</h3>
-                    <p><span class="method">POST</span><span class="endpoint-url">/register</span></p>
-                    <p>This endpoint is used to register the username and password.</p>
-                    
-                    <h4>cURL Request:</h4>
-                    <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/register' \
-                      -H "Content-Type: application/json" \
-                      -d '{
-                            "username": "testuser",
-                            "password": "testpassword"
-                          }'</code></pre>
-
-                          <h4>Python Implementation:</h4>
-                    <pre><code class="language-python">
-                    import requests
-                    import json
-                    
-                    class RegisterResponse:
-                        """Class to handle API response"""
-                        def __init__(self, message, user):
-                            self.message = message
-                            self.user = user
-                    
-                        @classmethod
-                        def from_json(cls, json_data):
-                            return cls(
-                                message=json_data.get("message"),
-                                user=json_data.get("user")
-                            )
-                    
-                    def register(username: str, password: str):
-                        """Sends a POST request to register a new user."""
-                        url = "https://humblebeeai-llm-host.hf.space/register"
-                        headers = {"Content-Type": "application/json"}
-                        payload = {"username": username, "password": password}
-                    
-                        try:
-                            response = requests.post(url, json=payload, headers=headers)
-                    
-                            if response.status_code == 200:
-                                return RegisterResponse.from_json(response.json())
-                            else:
-                                raise Exception(f"Failed to register: {response.text}")
-                    
-                        except requests.exceptions.RequestException as e:
-                            raise Exception(f"Network error: {e}")
-                    
-                    # Example usage
-                    try:
-                        result = register("testuser", "testpassword")
-                        print(f"✅ Registration successful! User: {result.user}, Message: {result.message}")
-                    except Exception as e:
-                        print(f"⚠️ Error: {e}")
-                    </code></pre>
-                    
-                    <h4>Response:</h4>
-                    <pre><code class="language-json">{"message":"User registered successfully","user":"bahodir"}</code></pre>
-                    
-              </div>
-              <div class="endpoint" id="login">
-                  <h3>2. Login Endpoint</h3>
-                  <p><span class="method">POST</span><span class="endpoint-url">/login</span></p>
-                  <p>This endpoint is used to authenticate a user and retrieve an access token.</p>
-          
-                  <h4>cURL Request:</h4>
-                  <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/login' \
-               -H "Content-Type: application/x-www-form-urlencoded" \
-               -d 'username=testuser&password=testpassword'</code></pre>
-          
-                  <h4>Python Implementation:</h4>
-                  <pre><code class="language-python">
-          import requests
-          
-          class LoginResponse:
-              """Class to handle API login response"""
-              def __init__(self, access_token, refresh_token, token_type):
-                  self.access_token = access_token
-                  self.refresh_token = refresh_token
-                  self.token_type = token_type
-          
-              @classmethod
-              def from_json(cls, json_data):
-                  return cls(
-                      access_token=json_data.get("access_token"),
-                      refresh_token=json_data.get("refresh_token"),
-                      token_type=json_data.get("token_type"),
-                  )
-          
-          def login(username: str, password: str):
-              """Sends a POST request to authenticate a user."""
-              url = "https://humblebeeai-llm-host.hf.space/login"
-              headers = {"Content-Type": "application/x-www-form-urlencoded"}
-              payload = {"username": username, "password": password}
-          
-              try:
-                  response = requests.post(url, data=payload, headers=headers)
-          
-                  if response.status_code == 200:
-                      return LoginResponse.from_json(response.json())
-                  else:
-                      raise Exception(f"Failed to login: {response.text}")
-          
-              except requests.exceptions.RequestException as e:
-                  raise Exception(f"Network error: {e}")
-          
-          # Example usage
-          try:
-              result = login("testuser", "testpassword")
-              print(f"✅ Login successful! Access Token: {result.access_token}")
-          except Exception as e:
-              print(f"⚠️ Error: {e}")
-                  </code></pre>
-          
-                  <h4>Response:</h4>
-                  <pre><code class="language-json">{ "access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0dXNlciIsImV4cCI6MTczOTE3Nzg5N30.jUfB7vHA4HGrpDiI08cpKGR7s3DOVrchhpf5yBz0hCc",
-                  "token_type":"bearer",
-                  "refresh_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0dXNlciIsImV4cCI6MTczOTc4MDg5N30.L9_5hGR_lUskUINccE51fOA1-8NOgmQ2bjBK3iMS-K8"}</code></pre>
-          
-              </div>
-
-
-              <div class="endpoint" id="refresh">
+        
+            <div class="endpoint" id="register">
+                <h3>1. Register Endpoint</h3>
+                <p><span class="method">POST</span><span class="endpoint-url">/register</span></p>
+                <p>This endpoint is used to register the username and password.</p>
+        
+                <h4>cURL Request:</h4>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/register' \
+                  -H "Content-Type: application/json" \
+                  -d '{
+                        "username": "testuser",
+                        "password": "testpassword"
+                      }'</code></pre>
+        
+                <h4>Response:</h4>
+                <pre><code class="language-json">{"message":"User registered successfully","user":"bahodir"}</code></pre>
+            </div>
+        
+            <div class="endpoint" id="login">
+                <h3>2. Login Endpoint</h3>
+                <p><span class="method">POST</span><span class="endpoint-url">/login</span></p>
+                <p>This endpoint is used to authenticate a user and retrieve an access token.</p>
+        
+                <h4>cURL Request:</h4>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/login' \
+                 -H "Content-Type: application/x-www-form-urlencoded" \
+                 -d 'username=testuser&password=testpassword'</code></pre>
+        
+                <h4>Response:</h4>
+                <pre><code class="language-json">{
+                    "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+                    "token_type": "bearer",
+                    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+                }</code></pre>
+            </div>
+        
+            <div class="endpoint" id="refresh">
                 <h3>3. 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-llm-host.hf.space/refresh' \
                  -H "Content-Type: application/json" \
                  -d '{"refresh_token": "your-refresh-token"}'</code></pre>
-            
-                <h4>Python Implementation:</h4>
-                <pre><code class="language-python">
-            import requests
-            import json
-            
-            class RefreshResponse:
-                """Class to handle API refresh response"""
-                def __init__(self, access_token, refresh_token, token_type):
-                    self.access_token = access_token
-                    self.refresh_token = refresh_token
-                    self.token_type = token_type
-            
-                @classmethod
-                def from_json(cls, json_data):
-                    return cls(
-                        access_token=json_data.get("access_token"),
-                        refresh_token=json_data.get("refresh_token"),
-                        token_type=json_data.get("token_type"),
-                    )
-            
-            def refresh_token(refresh_token: str):
-                """Sends a POST request to refresh the access token."""
-                url = "https://humblebeeai-llm-host.hf.space/refresh"
-                headers = {"Content-Type": "application/json"}
-                payload = {"refresh_token": refresh_token}
-            
-                try:
-                    response = requests.post(url, json=payload, headers=headers)
-            
-                    if response.status_code == 200:
-                        return RefreshResponse.from_json(response.json())
-                    else:
-                        raise Exception(f"Failed to refresh token: {response.text}")
-            
-                except requests.exceptions.RequestException as e:
-                    raise Exception(f"Network error: {e}")
-            
-            # Example usage
-            try:
-                result = refresh_token("your-refresh-token")
-                print(f"✅ Token refreshed! New Access Token: {result.access_token}")
-            except Exception as e:
-                print(f"⚠️ 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"
-            }</code></pre>
-              </div>
-            
-              <div class="endpoint" id="search">
-    <h3>4. 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-llm-host.hf.space/search' \
-     -H "Content-Type: application/json" \
-     -H "Authorization: Bearer your-access-token" \
-     -d '{"query": "test query"}'</code></pre>
-
-    <h4>Python Implementation:</h4>
-    <pre><code class="language-python">
-import requests
-import json
-
-class SearchResult:
-    """Class to handle search results"""
-    def __init__(self, text, similarity, model_type):
-        self.text = text
-        self.similarity = similarity
-        self.model_type = model_type
-
-    @classmethod
-    def from_json(cls, json_data):
-        return cls(
-            text=json_data.get("text"),
-            similarity=json_data.get("similarity"),
-            model_type=json_data.get("model_type"),
-        )
-
-def search(query: str, access_token: str):
-    """Sends a search query and retrieves results."""
-    url = "https://humblebeeai-llm-host.hf.space/search"
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {access_token}"
-    }
-    payload = {"query": query}
-
-    try:
-        response = requests.post(url, json=payload, headers=headers)
-
-        if response.status_code == 200:
-            json_list = response.json()
-            return [SearchResult.from_json(item) for item in json_list]
-        else:
-            raise Exception(f"Search failed: {response.text}")
-
-    except requests.exceptions.RequestException as e:
-        raise Exception(f"Network error: {e}")
-
-# Example usage
-try:
-    results = search("test query", "your-access-token")
-    for result in results:
-        print(f"✅ Found: {result.text} (Similarity: {result.similarity}, Model: {result.model_type})")
-except Exception as e:
-    print(f"⚠️ Error: {e}")
-    </code></pre>
-
-    <h4>Response:</h4>
-    <pre><code class="language-json">
-   response based on query
-</code></pre>
-              </div>
-
-
+                    "access_token": "new-access-token",
+                    "refresh_token": "your-refresh-token",
+                    "token_type": "bearer"
+                }</code></pre>
+            </div>
+        
+            <div class="endpoint" id="generate">
+                <h3>4. Generate Endpoint</h3>
+                <p><span class="method">POST</span><span class="endpoint-url">/generate</span></p>
+                <p>This endpoint is used to generate text based on a query. It requires a valid access token and supports optional streaming.</p>
+        
+                <h4>cURL Request:</h4>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/generate?stream=true' \
+                 -H "Content-Type: application/json" \
+                 -H "Authorization: Bearer your-access-token" \
+                 -d '{"query": "test query"}'</code></pre>
+        
+                <h4>Response:</h4>
+                <pre><code class="language-json">{
+                    "content": "Generated response text based on the query."
+                }</code></pre>
+        
+                <h4>Streaming Response:</h4>
+                <pre><code class="language-json">
+                data: {"content": "First streamed response chunk"}
+                data: {"content": "Second streamed response chunk"}
+                </code></pre>
+            </div>
         </section>
+        
 
         <section id="workflow">
             <h2>Workflow Example</h2>
@@ -285,29 +108,38 @@ except Exception as e:
             <h3>cURL Implementation</h3>
         
             <div class="endpoint">
-                <h3>Step 1: Login</h3>
-                <pre><code class="language-bash">curl -X POST https://humblebeeai-llm-host.hf.space/login \
-         -H "Content-Type: application/x-www-form-urlencoded" \
-         -d 'username=user123&password=password123'</code></pre>
+                <h3>Step 1: Register</h3>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/register' \
+                  -H "Content-Type: application/json" \
+                  -d '{
+                        "username": "testuser",
+                        "password": "testpassword"
+                      }'</code></pre>
             </div>
         
             <div class="endpoint">
-                <h3>Step 2: Search</h3>
-                <pre><code class="language-bash">curl -X POST https://humblebeeai-llm-host.hf.space/search \
-         -H "Content-Type: application/json" \
-         -H "Authorization: Bearer your-access-token" \
-         -d '{"query": "test query"}'</code></pre>
+                <h3>Step 2: Login</h3>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/login' \
+                 -H "Content-Type: application/x-www-form-urlencoded" \
+                 -d 'username=testuser&password=testpassword'</code></pre>
             </div>
         
             <div class="endpoint">
-                <h3>Step 3: Refresh Token</h3>
-                <pre><code class="language-bash">curl -X POST https://humblebeeai-llm-host.hf.space/refresh \
-         -H "Content-Type: application/json" \
-         -d '{"refresh_token": "your-refresh-token"}'</code></pre>
+                <h3>Step 3: Generate</h3>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/generate?stream=true' \
+                 -H "Content-Type: application/json" \
+                 -H "Authorization: Bearer your-access-token" \
+                 -d '{"query": "test query"}'</code></pre>
             </div>
         
-            <h3>Python Implementation</h3>
+            <div class="endpoint">
+                <h3>Step 4: Refresh Token</h3>
+                <pre><code class="language-bash">curl -X POST 'https://humblebeeai-llm-host.hf.space/refresh' \
+                 -H "Content-Type: application/json" \
+                 -d '{"refresh_token": "your-refresh-token"}'</code></pre>
+            </div>
         
+            <h3>Python Implementation</h3>
             <div class="endpoint">
                 <h4>Complete Python Example</h4>
                 <pre><code class="language-python">
@@ -323,8 +155,20 @@ except Exception as e:
                 self.access_token = None
                 self.refresh_token = None
         
+            def register(self, username: str, password: str):
+                """Registers a new user."""
+                url = f"{API_BASE_URL}/register"
+                payload = {"username": username, "password": password}
+                headers = {"Content-Type": "application/json"}
+        
+                response = requests.post(url, json=payload, headers=headers)
+                if response.status_code == 200:
+                    print("✅ Registration successful!")
+                else:
+                    raise Exception(f"⚠️ Registration failed: {response.text}")
+        
             def login(self, username: str, password: str):
-                """Authenticates the user and retrieves tokens"""
+                """Authenticates the user and retrieves tokens."""
                 url = f"{API_BASE_URL}/login"
                 payload = {"username": username, "password": password}
                 headers = {"Content-Type": "application/x-www-form-urlencoded"}
@@ -338,40 +182,29 @@ except Exception as e:
                 else:
                     raise Exception(f"⚠️ Login failed: {response.text}")
         
-            def search(self, query: str):
-                """Performs a search query"""
-                url = f"{API_BASE_URL}/search"
+            def generate(self, query: str, stream: bool = False):
+                """Generates content based on query."""
+                url = f"{API_BASE_URL}/generate?stream={str(stream).lower()}"
                 payload = {"query": query}
                 headers = {
                     "Content-Type": "application/json",
                     "Authorization": f"Bearer {self.access_token}",
                 }
         
-                response = requests.post(url, json=payload, headers=headers)
-                if response.status_code == 200:
-                    results = response.json()
-                    print("✅ Search results:", results)
-                    return results
-                else:
-                    raise Exception(f"⚠️ Search failed: {response.text}")
-        
-            def save_data(self, items: list):
-                """Saves retrieved data"""
-                url = f"{API_BASE_URL}/save"
-                payload = {"items": items}
-                headers = {
-                    "Content-Type": "application/json",
-                    "Authorization": f"Bearer {self.access_token}",
-                }
+                response = requests.post(url, json=payload, headers=headers, stream=stream)
         
-                response = requests.post(url, json=payload, headers=headers)
                 if response.status_code == 200:
-                    print("✅ Data saved successfully!")
+                    if stream:
+                        for line in response.iter_lines():
+                            if line:
+                                print(json.loads(line.decode("utf-8")).get("content"))
+                    else:
+                        return response.json()
                 else:
-                    raise Exception(f"⚠️ Failed to save data: {response.text}")
+                    raise Exception(f"⚠️ Request failed: {response.text}")
         
             def refresh_token(self):
-                """Refreshes access token"""
+                """Refreshes access token."""
                 url = f"{API_BASE_URL}/refresh"
                 payload = {"refresh_token": self.refresh_token}
                 headers = {"Content-Type": "application/json"}
@@ -388,25 +221,16 @@ except Exception as e:
         client = APIClient()
         
         try:
-            # Step 1: Login
-            client.login("user123", "password123")
-        
-            # Step 2: Perform Search
-            search_results = client.search("test query")
-        
-            # Step 3: Save Data (assuming we got some results)
-            if search_results:
-                save_items = [
-                    {
-                        "user_type": "user",
-                        "username": "user123",
-                        "query": "test query",
-                        "retrieved_text": search_results[0]["text"],
-                        "model_type": search_results[0]["model_type"],
-                        "reaction": "positive",
-                    }
-                ]
-                client.save_data(save_items)
+            # Step 1: Register
+            client.register("testuser", "testpassword")
+        
+            # Step 2: Login
+            client.login("testuser", "testpassword")
+        
+            # Step 3: Generate response
+            response = client.generate("test query", stream=True)
+            if response:
+                print(f"✅ Response: {response}")
         
             # Step 4: Refresh Token
             client.refresh_token()
@@ -416,12 +240,21 @@ except Exception as e:
                 </code></pre>
             </div>
         
-            <h4>Response:</h4>
+            <h3>Example Responses:</h3>
             <pre><code class="language-json">{
-            "access_token": "your-access-token",
-            "refresh_token": "your-refresh-token",
-            "token_type": "bearer",
-        }</code></pre>
+                "access_token": "your-access-token",
+                "refresh_token": "your-refresh-token",
+                "token_type": "bearer"
+            }</code></pre>
+        
+            <pre><code class="language-json">{
+                "content": "Generated response text based on the query."
+            }</code></pre>
+        
+            <pre><code class="language-json">
+            data: {"content": "First streamed response chunk"}
+            data: {"content": "Second streamed response chunk"}
+            </code></pre>
         </section>
         
         </main>

static/script.js

@@ -4,7 +4,7 @@ const sections = [
     { id: 'register', title: 'Register' },
     { id: 'login', title: 'Login' },
     { id: 'refresh', title: 'Refresh Token' },
-    { id: 'search', title: 'Search' },
+    { id: 'generate', title: 'Generate' },
     { id: 'workflow', title: 'Workflow Example' }
 ];
 

utils.py

@@ -1,8 +1,9 @@
 import asyncio
 import ollama
+import json
 
 async def generate_stream(query: str):
-    """Generates streamed responses from Ollama using LLaMA 3."""
+    """Generates streamed responses from Ollama using LLaMA 3 in JSON format."""
     try:
         stream = ollama.chat(
             model="llama3.2",
@@ -10,10 +11,22 @@ async def generate_stream(query: str):
             stream=True
         )
 
-        # Stream output without unnecessary delay
         for chunk in stream:
             if "message" in chunk and "content" in chunk["message"]:
-                yield chunk["message"]["content"]  # ✅ No sleep needed
+                response_data = json.dumps({"content": chunk["message"]["content"]})
+                yield f"data: {response_data}\n\n"  # SSE format
 
     except Exception as e:
-        yield f"⚠️ Error: {str(e)}"
+        error_data = json.dumps({"error": str(e)})
+        yield f"data: {error_data}\n\n"
+
+async def generate_response(query: str):
+    """Returns a non-streamed response."""
+    try:
+        response = ollama.chat(
+            model="llama3.2",
+            messages=[{"role": "user", "content": query}]
+        )
+        return {"content": response["message"]["content"]}
+    except Exception as e:
+        return {"error": str(e)}