Upload 2 files

src/RAG.py

@@ -0,0 +1,228 @@
+#from texts import *
+from langgraph.graph import StateGraph
+from langchain_core.runnables import RunnableLambda
+from openai import OpenAI
+import os 
+import openai
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import torch
+from typing import TypedDict
+import requests
+import json
+from typing import List, Dict, Any
+from sklearn.cluster import KMeans
+import numpy as np 
+from dotenv import load_dotenv
+file_text=''
+
+load_dotenv()
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=1024,
+    chunk_overlap=256,
+    length_function=len
+)
+openai.api_key = os.getenv('OPENAI_API_KEY')
+client=OpenAI()
+
+# def get_embedding(text, model="text-embedding-3-small"):
+#     # response = openai.embeddings.create(
+#     #     input=[text],
+#     #     model=model
+#     # )
+#     embeddings = encoder.encode([text], convert_to_tensor=True, show_progress_bar=True)
+#     embeddings = embeddings.cpu().numpy()
+#     return embeddings
+# text=chuncked_text+Focusing_text+planning_text+Focusing_text2+Evoking_text
+# chunks=text_splitter.split_text(text)
+# embeddings=[get_embedding(chunk) for chunk in chunks]
+# embedds=np.array(embeddings)
+# kmeans=KMeans(n_clusters=3,max_iter=1000)
+# kmeans.fit(embedds)
+
+# def embed_document(state,file_text):
+#     chunks=text_splitter.split_text(file_text)
+    
+#     embeddings=encoder.encode(chunks, convert_to_tensor=True, show_progress_bar=False)
+#     embeddings=embeddings.cpu().numpy()
+#     print(len(embeddings))
+#     return {'single_query':state['single_query'],'embeddings':embeddings,'chunks':chunks}
+    
+
+
+def get_knowledge(state,embeddings,chunks,method='cosine'):
+    query_embedding = state['embedded_query']
+    if method=='cosine':
+    # Convert to tensor
+        query_tensor = torch.tensor(query_embedding, dtype=torch.float32).to('cpu')  # shape: [embedding_dim]
+        #embeddings_tensor = torch.tensor(embeddings, dtype=torch.float32).to('cuda')  # shape: [num_chunks, embedding_dim]
+        # Normalize
+        embeddings_tensor=torch.from_numpy(embeddings).to('cpu')
+        query_tensor = query_tensor / query_tensor.norm()
+        embeddings_tensor = embeddings_tensor / embeddings_tensor.norm(dim=1, keepdim=True)
+        # Compute cosine similarity
+        similarities = torch.matmul(query_tensor, embeddings_tensor.T)
+        print(similarities.shape)
+        top_k = 5
+        top_k_indices = torch.topk(similarities, k=top_k).indices
+        print(top_k_indices)
+        return {'embedded_query':state['embedded_query'],'knowledge':[chunks[i] for i in top_k_indices.squeeze(0)]}
+    # elif method=='Kmeans':
+    #     query_emb = np.array(get_embedding(state['single_query']))
+    # # Predict the closest cluster
+    #     cluster_idx = kmeans.predict([query_emb])[0]
+    # # Find indices of documents in this cluster
+    #     cluster_doc_indices = np.where(kmeans.labels_ == cluster_idx)[0]
+    # # Compute L2 (Euclidean) distance within the cluster
+    #     cluster_embs = np.array(embeddings)[cluster_doc_indices]
+    #     distances = np.linalg.norm(cluster_embs - query_emb, axis=1)
+    #     top_k=5
+    # # Get top_k most similar documents (smallest distances)
+    #     top_indices = distances.argsort()[:top_k]
+    #     return {'single_query':state['single_query'],'knowledge':[chunks[cluster_doc_indices[i]] for i in top_indices]}
+    
+
+def summerise_knowledge(state):
+    prompt="""
+    [system]
+    ## Instructions:
+    You are skillfull text analysist. Summerise the extracted information from uploaded file by the user. Make your summary as concice as possible.
+    ### Inputs:
+    Extracted Knowledge: 
+    {}
+    ### Output: 
+"""
+    text=""
+    chunks=state['knowledge']
+    for chunk in chunks:
+        text+=chunk
+    response=client.chat.completions.create(    
+        model="gpt-5-mini",
+        messages =[{'role':'user','content':prompt.format(text)}])
+    # url = "https://11434-dep-01k080agynagw33vkkb9xfxpkb-d.cloudspaces.litng.ai/api/chat"
+    # s = requests.Session()
+    # s.headers.update({"Authorization": "Bearer bf54d08f-e88a-4a4a-bd14-444c984eaa6e"})
+    # response = s.post(url, json={
+    #         "model": "hf.co/alibidaran/LLAMA3-instructive_reasoning-GGUF:Q8_0",
+    #         "messages":[{'role':'user','content':prompt.format(text)}] ,
+    #          "options": {
+    #         "temperature": 0.7,
+    #         "top_p": 0.95 # Set your desired top_p here
+    #     }
+            
+    #     })
+    # full_response = ""
+    # for line in response.iter_lines():
+    #     if line:
+    #         data = json.loads(line.decode("utf-8"))
+    #         message = data.get("message", {})
+    #         content = message.get("content", "")
+    #         full_response += content
+    #         if data.get("done", Falsurl = "https://800-01jy9pekct42qjmqxcap35g81s.cloudspaces.litng.ai/predict"):
+    #             break
+    print(response.choices[0].message)
+    return {'embedded_query':state['embedded_query'],'summary':response.choices[0].message.content}
+    #return {'single_query':state['single_query'],'summary':full_response}
+
+# def making_instructions(state):
+#     prompt="""
+#     [system]
+#     ## Instructions:
+#     You are skill full certificated psychologist. Create an instruction for the practitioner to help them how to behaive and respond to the client effectively.
+#     ## Input:
+#     [summary]
+#     {}
+#     ### Output: 
+# """
+
+#     response=client.chat.completions.create(    
+#         model="gpt-4o-mini",
+#     # api_base="https://litellm.llemma.net/",
+#     # api_key="sk-ZsStrG5lPoGnCHZl4NgcOA",
+#         messages =[{'role':'user','content':prompt.format(state['summary'])}],
+#         temperature=0.7,
+#         top_p=0.95,
+#         max_tokens=800)
+#     return {'query':state['query'],'instruction':response.choices[0].message}
+
+def respond(state):
+    system_prompt="""
+        You are a reasonable expert who thinks and answer the users question. 
+        Before respond first think and create a chain of thoughts in your mind. 
+        Then respond to the client. Also follow the retrived information in the ##Summary section. 
+        Your chain of thought and reflection must be in <thinking>..</thinking> format and your respond 
+        should be in the <output>..</output> format. 
+        """
+    user_prompt="""
+    ## Instructions:
+    {}
+    ## Summary:
+    {}
+    """
+    url="https://8000-01jy9pekct42qjmqxcap35g81s.cloudspaces.litng.ai/predict"
+    payload = { "user_prompt":user_prompt.format(state['single_query'],state['summary'])}
+    response = requests.post(url, data=payload)
+    return {'final_response':response.json()['output'][0]}
+#     messages=[
+#     {'role':'system', 'content':system_prompt}, 
+# ]
+    # messages+=[{'role':'user','content':user_prompt.format(state['single_query'],state['summary'])}]
+    # url = "https://11434-dep-01jx2gzqqspsvcvtgmabz6jkkz-d.cloudspaces.litng.ai/api/chat"
+    # s = requests.Session()
+    # s.headers.update({"Authorization": "Bearer bf54d08f-e88a-4a4a-bd14-444c984eaa6e"})
+    # response = s.post(url, json={
+    #         "model": "hf.co/alibidaran/LLAMA3-intructive_reasoning_GGUF:Q8_0",
+    #         "messages": messages,
+    #          "options": {
+    #         "temperature": 0.7  # Set your desired temperature here
+    # }
+            
+    # })
+    # # Collect the assistant's output
+    # full_response = ""
+
+    # for line in response.iter_lines():
+    #     if line:
+    #         data = json.loads(line.decode("utf-8"))
+    #         message = data.get("message", {})
+    #         content = message.get("content", "")
+    #         full_response += content
+    #         if data.get("done", False):
+    #             break
+    # response=client.chat.completions.create(    
+    #     model="gpt-4o-mini",
+    # # api_base="https://litellm.llemma.net/",
+    # # api_key="sk-ZsStrG5lPoGnCHZl4NgcOA",
+    #     messages =messages,
+    #     temperature=0.7,
+    #     top_p=0.95,)
+    #return {'final_response':full_response}
+
+def end_node(state):
+    #print("Response:\n", state["final_response"])
+    return {'knowledge':state["summary"]}
+class MyState(TypedDict):
+    #query: List[Dict[str, Any]]
+    embedded_query:list
+    knowledge: list
+    summary: str
+
+def load_graph(embeddings,chunks):
+    graph_builder = StateGraph(state_schema=MyState) 
+
+# Add nodes
+    graph_builder.set_entry_point('get_knowledge')
+    graph_builder.add_node("get_knowledge", RunnableLambda(lambda state: get_knowledge(state,embeddings,chunks,method='cosine')))
+    graph_builder.add_node("summarise", RunnableLambda(summerise_knowledge))
+    #graph_builder.add_node('instructuons', RunnableLambda(making_instructions))
+    #graph_builder.add_node("respond", RunnableLambda(respond))
+    graph_builder.add_node("end", RunnableLambda(end_node))
+
+    # Add edges
+    graph_builder.add_edge("get_knowledge", "summarise")
+    #graph_builder.add_edge("summarise", "respond")
+    #graph_builder.add_edge("instructuons",'respond')
+    graph_builder.add_edge("summarise", "end")
+
+    # Compile the graph
+    # graph = graph_builder.compile()
+    return graph_builder

src/database_center.py

@@ -0,0 +1,28 @@
+import firebase_admin
+from firebase_admin import credentials
+from firebase_admin import db,firestore
+import uuid
+import json 
+import dotenv 
+import os 
+dotenv.load_dotenv()
+# if not firebase_admin._apps:
+#     cred = credentials.Certificate("streamlitapp-13c03-firebase-adminsdk-fbsvc-0a346d6d6b.json")
+#     firebase_admin.initialize_app(cred)
+# db=firestore.client()   
+
+#db_transaction=db.collection('test_transactions')
+cred_json=os.environ['Firebase_Credential']
+if not firebase_admin._apps:
+    cred = credentials.Certificate(json.loads(cred_json))
+    firebase_admin.initialize_app(cred)
+db=firestore.client()   
+
+db_transaction=db.collection('test_transactions')
+# db_transaction.set(
+#     {
+#         'id':str(uuid.uuid4()),
+#         'app':'sparkAnime',
+#         'transaction-id':'igjepgjagpwogj'
+#     }
+# )