Update app.py

app.py

@@ -2,15 +2,22 @@ import gradio as gr
 import os
 import json
 import requests
-import openai
 
-# Set OpenAI API key
-openai.api_key = os.getenv('OPENAI_API_KEY')
+# Get Ragie API key
 ragie_api_key = os.getenv('RAGIE_API_KEY')
 
-def get_ragie_chunks(query):
-    """Retrieve chunks using Ragie's documented method"""
+def get_chunks(query):
+    """Retrieve chunks with detailed API response checking"""
     try:
+        # Print API key status (safely)
+        if ragie_api_key:
+            print("API key found")
+        else:
+            return "Error: No Ragie API key found in environment variables"
+            
+        print(f"\nSending query: {query}")
+            
+        # Make the API call
         response = requests.post(
             "https://api.ragie.ai/retrievals",
             headers={
@@ -20,81 +27,57 @@ def get_ragie_chunks(query):
             json={
                 "query": query,
                 "filter": {
-                    "scope": "tutorial"  # Adjust this to match your Ragie scope
+                    "scope": "tutorial"  # Adjust this to match your scope
                 }
             }
         )
         
+        # Print full response details
+        print(f"\nAPI Response Status: {response.status_code}")
+        print(f"Response Headers: {dict(response.headers)}")
+        
         if response.status_code != 200:
-            print(f"Ragie API error: {response.status_code}")
-            return []
+            error_detail = ""
+            try:
+                error_detail = response.json()
+                print(f"Error Response Body: {error_detail}")
+            except:
+                error_detail = response.text
+                print(f"Error Response Text: {error_detail}")
+            return f"""API Call Failed:
+Status Code: {response.status_code}
+Error Details: {error_detail}"""
             
+        # Parse the successful response
         data = response.json()
-        return [chunk["text"] for chunk in data.get("scored_chunks", [])]
-    except Exception as e:
-        print(f"Error getting chunks: {str(e)}")
-        return []
-
-def create_system_prompt(chunks):
-    """Create system prompt following Ragie's format"""
-    return f"""These are very important to follow:
-You are "Ragie AI", a professional but friendly AI chatbot working as an assistant.
-Your current task is to help the user based on all of the information available to you.
-Answer informally, directly, and concisely without a heading or greeting but include details.
-Use richtext Markdown when appropriate including bold, italic, paragraphs, and lists.
-If using LaTeX, use double $$ as delimiter instead of single $. Use $$....$$ instead of $..$$.
-Organize information into multiple sections or points when appropriate.
-Don't include raw item IDs or other raw fields from the source.
-Don't use XML or other markup unless requested by the user.
-
-Here is all of the information available to answer the user:
-===
-{chr(10).join(chunks)}
-===
-
-If the user asked for a search and there are no results, make sure to let the user know
-and what they might be able to do to find the information they need."""
-
-def respond(message, history):
-    """Main response function following Ragie's integration approach"""
-    try:
-        # Get chunks from Ragie using their method
-        chunks = get_ragie_chunks(message)
+        print(f"\nFound {len(data.get('scored_chunks', []))} chunks")
         
-        # Create messages array following their format
-        messages = [{"role": "system", "content": create_system_prompt(chunks)}]
-        
-        # Add conversation history
-        for human, assistant in history:
-            messages.append({"role": "user", "content": human})
-            messages.append({"role": "assistant", "content": assistant})
+        # Format the chunks with API response info
+        result = f"""API Call Successful:
+Status Code: {response.status_code}
+Number of Chunks: {len(data.get('scored_chunks', []))}
+
+Retrieved Chunks:
+"""
+        for i, chunk in enumerate(data.get("scored_chunks", []), 1):
+            result += f"\nChunk {i} (Score: {chunk['score']}):\n"
+            result += f"{chunk['text']}\n"
+            result += "-" * 50
         
-        # Add current message
-        messages.append({"role": "user", "content": message})
+        return result if data.get("scored_chunks") else "API call successful but no chunks were found for this query."
         
-        # Get streaming response from OpenAI
-        response = ""
-        for chunk in openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=messages,
-            temperature=0.7,
-            stream=True
-        ):
-            if hasattr(chunk.choices[0].delta, 'content'):
-                content = chunk.choices[0].delta.content
-                if content is not None:
-                    response += content
-                    yield response
-                
     except Exception as e:
-        print(f"Error in respond: {str(e)}")
-        yield f"I apologize, but I encountered an error: {str(e)}"
+        error_msg = f"Error during API call: {str(e)}"
+        print(error_msg)
+        return error_msg
 
-# Create the Gradio interface
-demo = gr.ChatInterface(
-    respond,
-    title="Ragie-Powered Chatbot",
-    description="A chatbot that combines Ragie's retrieval system with OpenAI's language capabilities."
+# Create a simple interface
+demo = gr.Interface(
+    fn=get_chunks,
+    inputs=gr.Textbox(label="Enter your query"),
+    outputs=gr.Textbox(label="API Response and Retrieved Chunks", lines=20),
+    title="Ragie Chunk Retriever with API Debugging",
+    description="Enter a query to see full API response details and retrieved chunks."
 )
 
 if __name__ == "__main__":