Spaces:

Patelcoder
/

Ai-Descripter

Running

App Files Files Community

Patelcoder commited on Jul 11

Commit

ab6d766

verified ·

1 Parent(s): 3cd727d

Delete index.html

Browse files

Files changed (1) hide show

index.html +0 -192

index.html DELETED Viewed

@@ -1,192 +0,0 @@
-<!DOCTYPE html>
-<html>
-<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" crossorigin src="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.js"></script>
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.css" />
-    <style>
-        body {
-            background-color: #0f172a;
-            color: #f8fafc;
-            font-family: 'Inter', system-ui, -apple-system, sans-serif;
-            margin: 0;
-            padding: 20px;
-        }
-    </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>