#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
file_text=''
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 .. format and your respond
should be in the 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