Spaces:

Patelcoder
/

Ai-Descripter

Running

App Files Files Community

Patelcoder commited on Jul 11

Commit

744a700

verified ·

1 Parent(s): e63b380

Update index.html

Browse files

Files changed (1) hide show

index.html +43 -159

index.html CHANGED Viewed

@@ -3,9 +3,11 @@
 <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Story RAG Assistant (Gradio-Lite)</title>
     <script type="module" src="https://gradio-lite-previews.s3.amazonaws.com/PINNED_HF_HUB/dist/lite.js"></script>
     <link rel="stylesheet" href="https://gradio-lite-previews.s3.amazonaws.com/PINNED_HF_HUB/dist/lite.css" />
     <style>
         body {
             background-color: #0f172a;
@@ -17,176 +19,58 @@
     </style>
 </head>
 <body>
-    <gradio-lite>
-        <gradio-code>
 import gradio as gr
-import json
-from pyodide.http import pyfetch
-async def make_post_request(url, headers, body_dict):
-    response = await pyfetch(
-        url,
-        method="POST",
-        headers=headers,
-        body=json.dumps(body_dict)
-    )
-    if response.status != 200:
-        err_msg = await response.string()
-        raise Exception(f"Request failed with status {response.status}: {err_msg}")
-    return await response.json()
-async def get_pinecone_host(api_key, index_name):
-    # Route control plane through corsproxy.io because Pinecone blocks browser CORS
-    url = f"https://corsproxy.io/?url=https://api.pinecone.io/indexes/{index_name}"
-    response = await pyfetch(
-        url,
-        method="GET",
-        headers={
-            "Api-Key": api_key,
-            "Accept": "application/json"
-        }
-    )
-    if response.status != 200:
-        err_msg = await response.string()
-        raise Exception(f"Failed to get Pinecone index info: {err_msg}")
-    data = await response.json()
-    return data["host"]
-async def query_pinecone(api_key, host, namespace, text, top_k=4):
-    # Route data plane through corsproxy.io
-    url = f"https://corsproxy.io/?url=https://{host}/query"
-    headers = {
-        "Api-Key": api_key,
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-    }
-    body = {
-        "namespace": namespace,
-        "topK": top_k,
-        "inputs": {
-            "text": text
-        },
-        "includeMetadata": True
-    }
-    data = await make_post_request(url, headers, body)
-    matches = data.get("matches", [])
-    chunks = [m["metadata"].get("chunk_text", "") for m in matches if "metadata" in m]
-    return chunks
-async def call_gemini(api_key, model_name, contents):
-    # Gemini API natively supports CORS, so we do not need a proxy for it
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent?key={api_key}"
-    headers = {
-        "Content-Type": "application/json"
-    }
-    body = {
-        "contents": contents,
-        "generationConfig": {
-            "temperature": 0.1
-        }
-    }
-    data = await make_post_request(url, headers, body)
-    try:
-        text = data["candidates"][0]["content"]["parts"][0]["text"]
-        return text
-    except (KeyError, IndexError):
-        raise Exception(f"Failed to parse Gemini response: {json.dumps(data)}")
-async def respond(message, history, google_key, pinecone_key, pinecone_index, pinecone_ns, google_model):
-    if not google_key or not pinecone_key:
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": "❌ Please provide both Google and Pinecone API keys in the configuration panel on the left."})
-        return "", history
     try:
-        # 1. Fetch Pinecone Host
-        host = await get_pinecone_host(pinecone_key, pinecone_index)
-        # 2. Search Pinecone for context
-        chunks = await query_pinecone(pinecone_key, host, pinecone_ns, message)
-        # 3. Format prompt
-        sources_text = "\n\n".join(f"Source {i+1}:\n{text}" for i, text in enumerate(chunks)) if chunks else "No relevant sources found."
-        system_prompt = (
-            "You are an educational assistant answering questions about stories in uploaded documents.\n"
-            "Rules:\n"
-            "- Use ONLY facts from the retrieved sources. Never invent details.\n"
-            "- Give a direct answer in 2-4 sentences. Do not repeat the question or show your reasoning.\n"
-            "- If multiple stories appear, answer about the one most relevant to the question.\n"
-            "- If the sources do not contain the answer, say you could not find it in the document."
         )
-        augmented_prompt = (
-            f"{system_prompt}\n\n"
-            f"Retrieved sources (answer using ONLY these):\n{sources_text}\n\n"
-            f"Question: {message}"
-        )
-        # 4. Construct conversation contents for Gemini
-        contents = []
-        for turn in history[-8:]:
-            role = "user" if turn["role"] == "user" else "model"
-            contents.append({
-                "role": role,
-                "parts": [{"text": turn["content"]}]
-            })
-        contents.append({
-            "role": "user",
-            "parts": [{"text": augmented_prompt}]
-        })
-        # 5. Call Gemini
-        response_text = await call_gemini(google_key, google_model, contents)
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": response_text})
-        return "", history
     except Exception as e:
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": f"❌ Error: {str(e)}"})
-        return "", history
-# Custom WebAssembly Theme and Styling
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo")) as demo:
-    gr.Markdown("# 📚 Static RAG Story Assistant (Gradio-Lite)")
-    gr.Markdown(
-        "This application runs **entirely inside your browser** via WebAssembly (Pyodide). "
-        "No backend server is required, and your API keys never leave your browser session (except to call Pinecone and Gemini)."
-    )
     with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### 🔑 API Configuration")
-            google_key_input = gr.Textbox(label="Google API Key", type="password", placeholder="AIzaSy...")
-            pinecone_key_input = gr.Textbox(label="Pinecone API Key", type="password", placeholder="pcsk_...")
-            pinecone_index_input = gr.Textbox(label="Pinecone Index Name", value="story-llama")
-            pinecone_ns_input = gr.Textbox(label="Pinecone Namespace", value="default")
-            google_model_input = gr.Textbox(label="Google Model", value="gemini-2.0-flash")
-        with gr.Column(scale=2):
-            chatbot = gr.Chatbot(type="messages", height=450)
-            msg_input = gr.Textbox(placeholder="Ask a question about the story...", label="Your Question")
-            with gr.Row():
-                submit_btn = gr.Button("Send", variant="primary")
-                clear_btn = gr.Button("Clear Chat")
     submit_btn.click(
-        respond,
-        inputs=[msg_input, chatbot, google_key_input, pinecone_key_input, pinecone_index_input, pinecone_ns_input, google_model_input],
-        outputs=[msg_input, chatbot]
-    )
-    msg_input.submit(
-        respond,
-        inputs=[msg_input, chatbot, google_key_input, pinecone_key_input, pinecone_index_input, pinecone_ns_input, google_model_input],
-        outputs=[msg_input, chatbot]
     )
-    clear_btn.click(lambda: [], None, chatbot)
 demo.launch()
-        </gradio-code>
-    </gradio-lite>
 </body>
-</html>

 <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AI Descriptor Agent</title>
     <script type="module" src="https://gradio-lite-previews.s3.amazonaws.com/PINNED_HF_HUB/dist/lite.js"></script>
     <link rel="stylesheet" href="https://gradio-lite-previews.s3.amazonaws.com/PINNED_HF_HUB/dist/lite.css" />
     <style>
         body {
             background-color: #0f172a;
     </style>
 </head>
 <body>
+    <gradio-app requirements="openai">
 import gradio as gr
+from openai import OpenAI
+def run_descriptor_agent(openai_key, user_prompt):
+    if not openai_key:
+        return "Please enter your OpenAI API Key first!"
     try:
+        # Initialize the OpenAI client inside the browser environment
+        client = OpenAI(api_key=openai_key)
+        # Simple agent descriptor call
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are a professional AI Descriptor agent. Provide structured, clear summaries and descriptions based on user requests."},
+                {"role": "user", "content": user_prompt}
+            ]
         )
+        return response.choices[0].message.content
     except Exception as e:
+        return f"Error: {str(e)}"
+# Define the Gradio UI
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo")) as demo:
+    gr.Markdown("# 🤖 AI Descriptor Agent")
+    gr.Markdown("This runs entirely in your browser. Your OpenAI key is safe and is not stored anywhere on Hugging Face.")
     with gr.Row():
+        key_input = gr.Textbox(
+            label="1. Enter your OpenAI API Key",
+            placeholder="sk-proj-...",
+            type="password"
+        )
+    with gr.Row():
+        prompt_input = gr.Textbox(
+            label="2. Ask the Agent anything",
+            placeholder="Describe what you want me to analyze..."
+        )
+    submit_btn = gr.Button("Run Agent", variant="primary")
+    output_text = gr.Textbox(label="Agent Response", interactive=False)
     submit_btn.click(
+        fn=run_descriptor_agent,
+        inputs=[key_input, prompt_input],
+        outputs=output_text
     )
 demo.launch()
+    </gradio-app>
 </body>
+</html>