Update app.py

app.py

@@ -1,85 +1,63 @@
-from fastapi import FastAPI, HTTPException
-import requests
-import oci
-import json
-from datetime import datetime
+import gradio as gr
+import chromadb
+from transformers import AutoTokenizer, AutoModel
+import faiss
+import numpy as np
+import torch
 
-app = FastAPI()
+# Load the pre-trained model and tokenizer
+model_name = "sentence-transformers/all-MiniLM-L6-v2"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModel.from_pretrained(model_name)
 
-# Oracle Cloud Configurations (Ensure your OCI config file is set up correctly)
-config = oci.config.from_file("~/.oci/config", "DEFAULT")
-signer = oci.auth.signers.get_resource_principals_signer()
+# Initialize Chroma client
+client = chromadb.Client()
 
-# Endpoint URL for Oracle AI Service (Replace region appropriately)
-oci_endpoint = "https://anomalydetection.aiservice.{{region}}.oci.oraclecloud.com/20210101/aiPrivateEndpoints"
+# Create a Chroma collection
+collection = client.create_collection(name="tree_images")
 
-# Request headers including authentication (ensure the correct signing/authentication process)
-headers = {
-    "Content-Type": "application/json",
-    "Authorization": "Bearer {access_token}"  # Use the appropriate method to authenticate
-}
+# Example data (you can replace this with your actual content or dataset)
+content = ["Tree 1: Decorated with lights", "Tree 2: Undecorated", "Tree 3: Decorated with ornaments"]
 
-@app.post("/create-private-endpoint")
-async def create_private_endpoint(compartment_id: str, subnet_id: str, display_name: str, dns_zones: list):
-    """Creates a private reverse connection endpoint in Oracle Cloud"""
-    
-    # Prepare the request body
-    request_body = {
-        "compartmentId": compartment_id,
-        "subnetId": subnet_id,
-        "displayName": display_name,
-        "dnsZones": dns_zones,
-        "definedTags": {},
-        "freeformTags": {}
-    }
-    
-    response = requests.post(
-        oci_endpoint,
-        headers=headers,
-        data=json.dumps(request_body)
-    )
-    
-    if response.status_code == 202:
-        return {"message": "Private endpoint created successfully", "status": response.status_code}
-    else:
-        raise HTTPException(status_code=response.status_code, detail=response.json())
+# Function to generate embeddings using the pre-trained model
+def generate_embeddings(texts):
+    embeddings = []
+    for text in texts:
+        inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
+        with torch.no_grad():
+            output = model(**inputs)
+            embeddings.append(output.last_hidden_state.mean(dim=1).squeeze().numpy())
+    return embeddings
 
-@app.put("/update-private-endpoint/{endpoint_id}")
-async def update_private_endpoint(endpoint_id: str, display_name: str, dns_zones: list):
-    """Updates a private reverse connection endpoint"""
-    
-    update_url = f"{oci_endpoint}/{endpoint_id}"
-    
-    request_body = {
-        "displayName": display_name,
-        "dnsZones": dns_zones,
-        "definedTags": {},
-        "freeformTags": {}
-    }
-    
-    response = requests.put(
-        update_url,
-        headers=headers,
-        data=json.dumps(request_body)
-    )
-    
-    if response.status_code == 202:
-        return {"message": "Private endpoint updated successfully", "status": response.status_code}
-    else:
-        raise HTTPException(status_code=response.status_code, detail=response.json())
+# Generate embeddings for the content
+embeddings = generate_embeddings(content)
+
+# Add the embeddings to Chroma
+for idx, text in enumerate(content):
+    collection.add(embedding=embeddings[idx], document=text, metadatas={"id": idx})
+
+# Build FAISS index for efficient retrieval
+embeddings_np = np.array(embeddings).astype('float32')
+faiss_index = faiss.IndexFlatL2(embeddings_np.shape[1])
+faiss_index.add(embeddings_np)
 
-@app.get("/get-private-endpoint/{endpoint_id}")
-async def get_private_endpoint(endpoint_id: str):
-    """Retrieves a private reverse connection endpoint by its ID"""
+# Define the search function for Gradio interface
+def search(query):
+    # Generate embedding for the query
+    query_embedding = generate_embeddings([query])[0].reshape(1, -1)
     
-    get_url = f"{oci_endpoint}/{endpoint_id}"
+    # FAISS-based search
+    distances, indices = faiss_index.search(query_embedding, 3)
+    faiss_results = [content[i] for i in indices[0]]
     
-    response = requests.get(
-        get_url,
-        headers=headers
-    )
+    # Chroma-based search
+    chroma_results = collection.query(query_embeddings=query_embedding, n_results=3)["documents"]
     
-    if response.status_code == 200:
-        return response.json()
-    else:
-        raise HTTPException(status_code=response.status_code, detail=response.json())
+    # Return results
+    return "FAISS Results: " + ", ".join(faiss_results) + "\nChroma Results: " + ", ".join(chroma_results)
+
+# Create the Gradio interface
+interface = gr.Interface(fn=search, inputs="text", outputs="text")
+
+# Launch the Gradio interface
+interface.launch()