Upload 8 files

app.py

@@ -0,0 +1,105 @@
+import uuid
+from wrappers import *
+from embedding_loader import *
+from initialize_db import QdrantClientInitializer
+from pdf_loader import PDFLoader
+from IPython.display import display, Markdown
+import gradio as gr
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain.memory import ConversationBufferMemory
+from langchain_core.chat_history import InMemoryChatMessageHistory
+
+embeddings = import_embedding()
+AZURE_OPENAI_KEY = os.getenv('azure_api')
+os.environ['AZURE_OPENAI_KEY'] = AZURE_OPENAI_KEY
+openai.api_version = "2024-02-15-preview" # change it with your own version
+openai.azure_endpoint = os.getenv('azure_endpoint')
+model = "gpt35turbo" # deployment name on Azure OPENAI Studio
+myLLM = AzureChatOpenAI(azure_endpoint = openai.azure_endpoint, 
+                            api_key=AZURE_OPENAI_KEY,  
+                            api_version=openai.api_version,
+                            temperature=0,
+                            streaming=True, 
+                            model = model,)
+
+obj_qdrant = QdrantClientInitializer()
+client = obj_qdrant.initialize_db()
+obj_loader = PDFLoader()
+
+def print_result(question, result):
+  output_text = f"""### Question: 
+  {question}
+  ### Answer: 
+  {result}
+  """
+  return(output_text)
+
+def format_chat_prompt(chat_history):
+    prompt = []
+
+    for turn in chat_history:
+        user_message, ai_message = turn
+        prompt.append(HumanMessage(user_message))
+        prompt.append(AIMessage(ai_message))
+    
+    chat_history = InMemoryChatMessageHistory(messages=prompt)
+    memory = ConversationBufferMemory(chat_memory=chat_history, memory_key="history", input_key="question")
+    return memory
+
+def chat(question, manual, history):
+    history = history or []
+    memory = format_chat_prompt(history)
+    manual_list = {"Toyota_Corolla_2024_TR": -8580416610875007536, 
+                   "Renault_Clio_2024_TR":-5514489544983735006, 
+                   "Fiat_Egea_2024_TR":-2026113796962100812}
+    
+    collection_list = {"Toyota_Corolla_2024_TR": "TOYOTA_MANUAL_COLLECTION_EMBED3", 
+                   "Renault_Clio_2024_TR": "RENAULT_MANUAL_COLLECTION_EMBED3", 
+                   "Fiat_Egea_2024_TR": "FIAT_MANUAL_COLLECTION_EMBED3"}
+    
+    collection_name = collection_list[f"{manual}"]
+
+    db = obj_loader.load_from_database(embeddings=embeddings, collection_name=collection_name)
+    
+    CAR_ID = manual_list[f"{manual}"]
+    wrapper = Wrappers(collection_name, client, embeddings, myLLM, db, CAR_ID, memory)
+    
+    inputs = {"question": question, "iter_halucination": 0}
+    app = wrapper.lagchain_graph()
+
+    for output in app.stream(inputs):
+        for key, value in output.items():
+            pprint(f"Finished running: {key}:")
+    # display(Markdown(print_result(question, value["generation"]['text']))) 
+    response = value["generation"]['text']
+    history.append((question, response))
+
+    point_id = uuid.uuid4().hex
+    DatabaseOperations.save_user_history_demo(client, "USER_COLLECTION_EMBED3", question, response, embeddings, point_id, manual)
+
+    return '', history
+
+def vote(data: gr.LikeData):
+    if data.liked:
+        print("You upvoted this response: ")
+        return "OK"
+    else:
+        print("You downvoted this response: " )
+        return "NOK"
+
+
+
+manual_list = ["Toyota_Corolla_2024_TR", "Renault_Clio_2024_TR", "Fiat_Egea_2024_TR"]
+
+with gr.Blocks() as demo:
+
+    chatbot = gr.Chatbot(height=600)
+    manual = gr.Dropdown(label="Kullanım Kılavuzları", value="Toyota_Corolla_2024_TR", choices=manual_list)
+    textbox = gr.Textbox()
+    clear = gr.ClearButton(components=[textbox, chatbot], value='Clear console')
+    textbox.submit(chat, [textbox, manual, chatbot], [textbox, chatbot])
+    chatbot.like(vote, None, None)  # Adding this line causes the like/dislike icons to appear in your chatbot
+
+# gr.close_all()   
+demo.launch(share=True)
+

db_operations.py

@@ -0,0 +1,91 @@
+import datetime
+from qdrant_client import QdrantClient, models
+from langchain_qdrant import Qdrant
+
+class DatabaseOperations:
+
+    def __init__(self):
+        pass
+
+    def save_user_history(client, collection_name, question, answer, embeddings, point_id, user_id, session_id):
+    
+        vector = embeddings.embed_documents([question])[0]
+        client.upsert(
+        collection_name=collection_name,
+        points=[
+            models.PointStruct(
+                id=point_id,
+                payload={"user_id": user_id,
+                        "session_id": session_id,
+                        "create_date": datetime.datetime.now().isoformat(),
+                        "question": question,
+                        "answer": answer},
+                vector=vector,
+            )
+        ],
+    )
+        
+    def save_user_history_demo(client, collection_name, question, answer, embeddings, point_id, manual):
+    
+        vector = embeddings.embed_documents([question])[0]
+        client.upsert(
+        collection_name=collection_name,
+        points=[
+            models.PointStruct(
+                id=point_id,
+                payload={"manual": manual,
+                         "create_date": datetime.datetime.now().isoformat(),
+                         "question": question,
+                         "answer": answer},
+                vector=vector,
+            )
+        ],
+    )    
+        
+    def question_history_search(client, collection_name, car_id, question, embeddings, threshold=0.9):
+
+        CAR_ID = car_id
+
+        vector = embeddings.embed_documents([question])[0]
+
+        search_result = client.search(collection_name=collection_name,
+                query_vector=vector,
+                query_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(key="car_id", match=models.MatchValue(value=CAR_ID)),
+                        models.FieldCondition(key="source_name", match=models.MatchValue(value="User Question"))
+                    ]
+                ),
+                score_threshold=threshold,
+                limit=1)
+        return search_result
+    
+    def user_history_scroll(client, collection_name, user_id, key="user_id"):
+
+        history = client.scroll(collection_name=collection_name,
+                scroll_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(key=key, match=models.MatchValue(value=user_id))
+                    ]
+                ))
+        return history
+
+    def save_question_history(client, collection_name, question, answer, embeddings, 
+                          point_id, car_id, source_name, model_year):
+    
+        vector = embeddings.embed_documents([question])[0]
+        client.upsert(
+        collection_name=collection_name,
+        points=[
+            models.PointStruct(
+                id=point_id,
+                payload={"source_name": source_name,
+                        "page_content": question,
+                        "car_id": car_id,
+                        "model_year": model_year,
+                        "create_date": datetime.datetime.now().isoformat(),
+                        "answer": answer},
+                vector=vector,
+            )
+        ],
+    )

embedding_loader.py

@@ -0,0 +1,22 @@
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_openai import AzureOpenAIEmbeddings
+import openai
+import os
+def import_embedding():
+    # embedding_name = None
+    # myEmbeddingModel  = HuggingFaceEmbeddings(
+    #     model_name = embedding_name,  
+    #     model_kwargs = {'device':'cuda'},
+    #     encode_kwargs={'normalize_embeddings':True})
+
+    AZURE_OPENAI_KEY = os.getenv('azure_api')
+    os.environ['AZURE_OPENAI_KEY'] = AZURE_OPENAI_KEY
+    openai.api_version = "2024-02-15-preview" # change it with your own version
+    openai.azure_endpoint = os.getenv('azure_endpoint')
+    embedding_name = "embedding3large" # deployment name on Azure OPENAI Studio
+    myEmbeddingModel = AzureOpenAIEmbeddings(azure_deployment=embedding_name,
+            azure_endpoint = openai.azure_endpoint, 
+            api_key=AZURE_OPENAI_KEY,  
+            api_version=openai.api_version)
+
+    return myEmbeddingModel

initialize_db.py

@@ -0,0 +1,41 @@
+import datetime
+import subprocess
+from qdrant_client import QdrantClient, models
+import os
+class QdrantClientInitializer:
+
+    def __init__(self):
+        pass
+
+    def run_docker(self):
+        # Define the Docker command
+        docker_command = [
+            "docker run -d -p 6333:6333 -p 6334:6334 \
+                -v $(pwd)/qdrant_storage:/qdrant/storage:z \
+                    qdrant/qdrant"
+        ]
+
+        # Run the Docker command
+        subprocess.run(docker_command, shell=True)
+        print("Docker container is running in the background.")
+
+    def initialize_db(self):
+        client = QdrantClient(
+            url=os.getenv('qdrant_url'), 
+            api_key=os.getenv('qdrant_api'), timeout=20)
+        # client = QdrantClient(url="http://localhost:6333", timeout=1200, grpc_port=6333)
+
+        return client
+
+    def create_collection(self, client, collection_name, vector_size=4096, distance=models.Distance.COSINE):
+
+        if client.collection_exists(collection_name=collection_name):
+            print("{name} is exist!".format(name=collection_name))
+
+        else:
+            print("Name is not exist!")
+            client.create_collection(collection_name=collection_name,
+                                     vectors_config=models.VectorParams(size=vector_size, 
+                                                                        distance=distance,
+                                                                        )
+                                    )

pdf_loader.py

@@ -0,0 +1,111 @@
+import json
+import os
+import uuid
+import datetime
+from qdrant_client import QdrantClient, models
+from langchain_core.load import dumpd, dumps, load, loads
+from langchain_community.document_loaders import AzureAIDocumentIntelligenceLoader
+from langchain.text_splitter import NLTKTextSplitter, RecursiveCharacterTextSplitter
+from langchain_qdrant import Qdrant
+
+class PDFLoader:
+
+    def __init__(self):
+        pass
+        
+    def pdf_reader(self, path):
+        key = None # change it with your own loader key
+        endpoint = None # change it with your own loader endpoint
+        analysis_features = ["ocrHighResolution"]
+        # PDF Loader
+        AzurePDFLoader = AzureAIDocumentIntelligenceLoader(
+                api_endpoint=endpoint, 
+                api_key=key, 
+                file_path=path, 
+                api_model="prebuilt-layout",
+                mode="page",
+                analysis_features=analysis_features
+            )
+        documents = AzurePDFLoader.load()
+        return documents
+
+    def save_raw_documents(self, path, name, documents):
+
+        log_file={"documents": dumpd(documents)}
+        log_file_name = os.path.join(path, name)
+
+        with open(log_file_name, 'w') as output_file:
+            print(json.dumps(log_file, indent=2), file=output_file)
+
+    def load_raw_documents(self, path, name):
+
+        log_file_name = os.path.join(path, name)
+
+        with open(log_file_name, 'rb') as output_file:
+            log_file= json.load(output_file)
+            
+        documents = load(log_file["documents"])
+        return documents
+    
+    def recursive_splitter(self, documents, chunk_size=1024, chunk_overlap=256):
+
+        # Splitter
+        mySplitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, 
+                                    chunk_overlap=chunk_overlap, 
+                                    add_start_index=False)
+        chunks = mySplitter.split_documents(documents)
+        return chunks
+    
+    def generate_vectors(self, chunks, embeddings, source_name):
+        vectors = []
+        metadatas = []
+        page_contents = []
+        for chunk in chunks:
+            page_contents.append(chunk.page_content)
+            
+            vector = embeddings.embed_documents([chunk.page_content])
+            vectors.append(vector)
+
+            meta = chunk.metadata
+            meta["source"] = source_name
+            metadatas.append(meta)
+
+        return page_contents, vectors, metadatas
+    
+    def save_to_database(self, chunks, embeddings, collection_name):
+    
+        qdrant = Qdrant.from_documents(
+        chunks,
+        embeddings,
+        url=os.getenv('qdrant_url'), 
+        api_key=os.getenv('qdrant_api'),
+        prefer_grpc=True,
+        collection_name=collection_name)
+
+    def load_from_database(self, embeddings, collection_name):
+
+        db = Qdrant.from_existing_collection(
+        embedding=embeddings,
+        url=os.getenv('qdrant_url'), 
+        api_key=os.getenv('qdrant_api'),
+        collection_name=collection_name)
+        
+        return db
+    
+    def save_manuals(self, client, collection_name, car_id, model_year, vectors, metadatas, page_contents):
+        
+        client.upsert(
+        collection_name=collection_name,
+        points=[
+            models.PointStruct(
+                id=uuid.uuid4().hex,
+                payload={"metadata":metadatas[idx],
+                        "page_content": page_contents[idx],
+                        "car_id": car_id,
+                        "model_year": model_year,
+                        "create_date": datetime.datetime.now().isoformat()},
+                vector=vector[0]
+            )
+            for idx, vector in enumerate(vectors)
+        ],
+    )

requirements.txt

@@ -0,0 +1,211 @@
+accelerate==0.34.2
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.0
+aiohttp==3.10.5
+aiosignal==1.3.1
+annotated-types==0.7.0
+anyio==4.4.0
+asttokens==2.4.1
+attrs==24.2.0
+azure-ai-documentintelligence==1.0.0b4
+azure-ai-ml==1.19.0
+azure-common==1.1.28
+azure-core==1.30.2
+azure-identity==1.17.1
+azure-mgmt-core==1.4.0
+azure-storage-blob==12.22.0
+azure-storage-file-datalake==12.16.0
+azure-storage-file-share==12.17.0
+backcall==0.2.0
+beautifulsoup4==4.12.3
+bleach==6.1.0
+boto3==1.35.15
+botocore==1.35.15
+cachetools==5.5.0
+certifi==2024.8.30
+cffi==1.17.1
+charset-normalizer==3.3.2
+click==8.1.7
+cohere==5.9.1
+colorama==0.4.6
+colorlog==6.8.2
+comm==0.2.2
+contourpy==1.3.0
+cryptography==43.0.1
+cycler==0.12.1
+dataclasses-json==0.6.7
+debugpy==1.8.5
+decorator==5.1.1
+defusedxml==0.7.1
+distro==1.9.0
+docopt==0.6.2
+et-xmlfile==1.1.0
+executing==2.1.0
+fastapi==0.114.2
+fastavro==1.9.7
+fastjsonschema==2.20.0
+ffmpy==0.4.0
+filelock==3.13.1
+fonttools==4.53.1
+frozenlist==1.4.1
+fsspec==2024.2.0
+google-api-core==2.19.2
+google-api-python-client==2.145.0
+google-auth==2.34.0
+google-auth-httplib2==0.2.0
+googleapis-common-protos==1.65.0
+gradio==4.44.0
+gradio_client==1.3.0
+greenlet==3.0.3
+grpcio==1.66.1
+grpcio-tools==1.66.1
+h11==0.14.0
+h2==4.1.0
+hpack==4.0.0
+httpcore==1.0.5
+httplib2==0.22.0
+httpx==0.27.2
+httpx-sse==0.4.0
+huggingface-hub==0.24.6
+hyperframe==6.0.1
+idna==3.8
+importlib_resources==6.4.5
+ipykernel==6.29.5
+ipython==8.12.3
+ipywidgets==8.1.5
+isodate==0.6.1
+jedi==0.19.1
+Jinja2==3.1.4
+jiter==0.5.0
+jmespath==1.0.1
+joblib==1.4.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+jupyter_client==8.6.2
+jupyter_core==5.7.2
+jupyterlab_pygments==0.3.0
+jupyterlab_widgets==3.0.13
+kiwisolver==1.4.7
+langchain==0.2.16
+langchain-community==0.2.16
+langchain-core==0.2.38
+langchain-huggingface==0.0.3
+langchain-openai==0.1.23
+langchain-qdrant==0.1.3
+langchain-text-splitters==0.2.4
+langgraph==0.2.19
+langgraph-checkpoint==1.0.9
+langsmith==0.1.117
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.22.0
+matplotlib==3.9.2
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mistune==3.0.2
+mpmath==1.3.0
+msal==1.31.0
+msal-extensions==1.2.0
+msrest==0.7.1
+multidict==6.1.0
+mypy-extensions==1.0.0
+nbclient==0.10.0
+nbconvert==7.16.4
+nbformat==5.10.4
+nest-asyncio==1.6.0
+networkx==3.2.1
+numpy==1.26.3
+oauthlib==3.2.2
+openai==1.44.1
+opencensus==0.11.4
+opencensus-context==0.1.3
+opencensus-ext-azure==1.1.13
+opencensus-ext-logging==0.1.1
+openpyxl==3.1.5
+orjson==3.10.7
+packaging==24.1
+pandas==2.2.2
+pandocfilters==1.5.1
+parameterized==0.9.0
+parso==0.8.4
+pexpect==4.9.0
+pickleshare==0.7.5
+pillow==10.2.0
+pipreqs==0.5.0
+platformdirs==4.3.2
+portalocker==2.10.1
+prompt_toolkit==3.0.47
+proto-plus==1.24.0
+protobuf==5.28.0
+psutil==6.0.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
+pyasn1==0.6.0
+pyasn1_modules==0.4.0
+pycparser==2.22
+pydantic==2.9.1
+pydantic_core==2.23.3
+pydash==8.0.3
+pydub==0.25.1
+Pygments==2.18.0
+PyJWT==2.9.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.2
+pyzmq==26.2.0
+qdrant-client==1.11.1
+referencing==0.35.1
+regex==2024.7.24
+requests==2.32.3
+requests-mock==1.12.1
+requests-oauthlib==2.0.0
+rich==13.8.1
+rpds-py==0.20.0
+rsa==4.9
+ruff==0.6.5
+s3transfer==0.10.2
+safetensors==0.4.5
+scikit-learn==1.5.1
+scipy==1.14.1
+semantic-router==0.0.65
+semantic-version==2.10.0
+sentence-transformers==3.0.1
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+soupsieve==2.6
+SQLAlchemy==2.0.34
+stack-data==0.6.3
+starlette==0.38.5
+strictyaml==1.7.3
+sympy==1.12
+tenacity==8.5.0
+threadpoolctl==3.5.0
+tiktoken==0.7.0
+tinycss2==1.3.0
+tokenizers==0.19.1
+tomlkit==0.12.0
+tornado==6.4.1
+tqdm==4.66.5
+traitlets==5.14.3
+transformers==4.44.2
+triton==2.3.0
+typer==0.12.5
+types-requests==2.32.0.20240907
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2024.1
+uritemplate==4.1.1
+urllib3==2.2.2
+uvicorn==0.30.6
+v==1
+wcwidth==0.2.13
+webencodings==0.5.1
+websockets==12.0
+widgetsnbextension==4.0.13
+yarg==0.1.9
+yarl==1.11.1

wrappers.py

@@ -0,0 +1,549 @@
+import os
+import openai
+from langchain_openai import AzureChatOpenAI
+from langchain.prompts import ChatPromptTemplate, PromptTemplate
+from qdrant_client.http import models as rest
+from qdrant_client import QdrantClient, models
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import LLMChain
+from langchain_community.utilities import GoogleSearchAPIWrapper
+from langchain_core.tools import Tool
+from typing_extensions import TypedDict
+from typing import List
+from langchain.schema import Document
+from pprint import pprint
+from langgraph.graph import END, StateGraph
+
+from db_operations import DatabaseOperations
+# from initialize_db import QdrantClientInitializer
+from embedding_loader import *
+
+class Wrappers:
+
+    def __init__(self, collection_name_manual, client, embeddings, LLM, db, CAR_ID, memory):
+        self.collection_name_manual = collection_name_manual
+        self.embeddings = embeddings
+        self.client = client
+        self.myLLM = LLM
+        self.db = db
+        self.CAR_ID = CAR_ID
+        self.memory =  memory
+        # self.memory =  ConversationBufferMemory(memory_key="history",
+        #                           input_key="question")
+    def translater(self):
+        template = """You are a Turkish-English translator. Translate the input to English considering vehicle/car domain terms.
+
+        Input: {question}
+
+        Answer: """
+
+        PROMPT = PromptTemplate.from_template(template)  # ----------------->  ChatPromptTemplate kullanmak daha sağlıklı
+
+        translate_chain = LLMChain(llm=self.myLLM, prompt=PROMPT)
+        # translate_chain = PROMPT | self.myLLM
+
+        return translate_chain
+    
+    def retriever(self):
+
+        retriever = self.db.as_retriever(search_kwargs={'k': 4}, filter=rest.Filter(
+            must=[
+                models.FieldCondition(key="car_id", match=models.MatchValue(value=self.CAR_ID))
+                ]
+              ))
+        
+        return retriever
+    
+    def grade_documents(self):
+        class GradeDocuments(BaseModel):
+            """Binary score for relevance check on retrieved documents."""
+
+            binary_score: str = Field(description="Documents are relevant to the question, 'yes' or 'no'")
+
+        # LLM with function call 
+        structured_llm_grader_docs = self.myLLM.with_structured_output(GradeDocuments)
+
+        # Prompt 
+        system = """You are a grader assessing relevance of a retrieved document to a user question. \n
+            Consider the following when making your assessment: \n
+            - Does the document directly address the user's question? \n
+            - Does it provide information or context that is pertinent to the question? \n
+            - Does it discuss relevant risks, benefits, recommendations, or considerations related to the question? \n
+            If the document contains keyword(s) or semantic meaning related or partially related to the question, grade it as relevant. \n
+            Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."""
+
+        grade_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                ("human", "Retrieved document: \n\n {document} \n\n User question: {question}"),
+            ]
+        )
+
+        retrieval_grader_relevance = grade_prompt | structured_llm_grader_docs
+
+        return retrieval_grader_relevance
+    
+    def lead_check(self):
+        
+        class LeadCheck(BaseModel):
+            """Binary score for service relevance check on question."""
+
+            binary_score: str = Field(description="Services are relevant to the question, 'yes' or 'no'")
+
+        # LLM with function call 
+        structured_llm_grader_service = self.myLLM.with_structured_output(LeadCheck)
+
+        # Prompt 
+        system = """You are a grader assessing relevance of services to a user question. \n
+            If the provided services related or partially related to the question, grade it as relevant. \n
+            Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question."""
+
+        lead_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                ("human", "Provided services: \n\n {hizmet_listesi} \n\n User question: {question}"),
+            ]
+        )
+
+        service_grader_relevance = lead_prompt | structured_llm_grader_service
+        
+        return service_grader_relevance
+    
+    def main_prompt(self):
+
+        prompt = ChatPromptTemplate.from_template(
+            """
+            You are an expert assistant named ARVI focused solely on car troubles and vehicle information. 
+            Your goal is to provide accurate, helpful, and clear answers to any questions related to car issues, maintenance, repairs, specifications, and other vehicle-related topics.
+
+            You are also designed to respond politely and appropriately to basic courteous interactions. Here are the guidelines:
+
+            1. Car Troubles and Vehicle Information:
+
+                - Always answer questions regarding car issues, diagnostics, repairs, maintenance, and vehicle specifications.
+                - Provide detailed and practical advice that can help users resolve their car troubles or understand more about their vehicles based on context.
+            
+            2. References:
+
+                - When answering a question, if you use specific information from the context, add the context's metadata (source and page) as references at the end of your response.
+                - Do not repeat same reference.
+                - Never include irrelevant context.
+
+            The first information you have is the relevant text that is automatically extracted from the manual or through the web search. \n
+            Context: {context} \n
+
+            History: {history} \n
+
+            Based on all the information provided, answer the following question briefly: \n
+            Question: {question} \n
+
+            Lead: {lead} \n
+            Do not use your prior knowledge! \n
+            If the question is too general, ask for specific information. \n
+            Answer: Answer in Turkish\n
+            References: 1: \n
+                        2: \n
+                        ...
+                        """
+        )
+
+        # Chain
+
+        # rag_chain = prompt | myLLM | StrOutputParser()
+        rag_chain =LLMChain(llm=self.myLLM, prompt=prompt, memory=self.memory)
+
+        return rag_chain
+    
+    def hallucination_grader(self):
+        class GradeHallucinations(BaseModel):
+            """Binary score for hallucination present in generation answer."""
+
+            binary_score: str = Field(description="Don't consider calling external APIs for additional information. Answer is supported by the facts, 'yes' or 'no'.")
+        
+        # LLM with function call 
+        structured_llm_grader_hallucination = self.myLLM.with_structured_output(GradeHallucinations)
+        
+        # Prompt 
+        system = """You are a grader assessing whether an LLM generation is supported by a set of retrieved facts. \n 
+            If the LLM generation is greetings sentences or say 'cannot answer the question", always consider it is a yes. \n
+            For others, restrict yourself to give a binary score, either 'yes' or 'no'. If the answer is supported or partially supported by the set of facts, consider it a yes. \n
+            Don't consider calling external APIs or prior knowledge for additional information as consistent with the facts."""
+
+        hallucination_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                ("human", "Set of facts: \n\n {documents} \n\n LLM generation: {generation}"),
+        ]
+        )
+        
+        hallucination_grader = hallucination_prompt | structured_llm_grader_hallucination
+
+        return hallucination_grader
+    
+    def answer_grader(self):
+        class GradeAnswer(BaseModel):
+            """Binary score to assess answer addresses question."""
+
+            binary_score: str = Field(description="Answer addresses the question, 'yes' or 'no'")
+
+        # LLM with function call 
+        structured_llm_grader_answer = self.myLLM.with_structured_output(GradeAnswer)
+
+        # Prompt 
+        system = """You are a grader assessing whether an answer addresses / resolves a question \n 
+            Give a binary score 'yes' or 'no'. Yes' means that the answer resolves the question. \n
+            If the LLM generation is greetings sentences, always consider it is a yes.\n
+            If the LLM generation said that 'I cannot answer that question", consider it is a yes."""
+
+        answer_prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system),
+                ("human", "User question: \n\n {question} \n\n LLM generation: {generation}"),
+            ]
+        )
+
+        answer_grader = answer_prompt | structured_llm_grader_answer
+
+        return answer_grader
+    
+
+    def web_search(self):
+        os.environ["GOOGLE_CSE_ID"] = os.getenv('google_search_id')
+        os.environ["GOOGLE_API_KEY"] = os.getenv('google_search_api')
+
+        search = GoogleSearchAPIWrapper()
+
+        def top3_results(query):
+            return search.results(query, 3)
+
+        web_search_tool = Tool(
+            name="google_search",
+            description="Search Google for recent results.",
+            func=top3_results,
+        )
+    
+        return web_search_tool
+    
+
+    def lagchain_graph(self):
+
+        class GraphState(TypedDict):
+            """
+            Represents the state of our graph.
+
+            Attributes:
+                question: question
+                generation: LLM generation
+                web_search: whether to add search
+                documents: list of documents 
+            """
+            question : str
+            generation : str
+            web_search : str
+            documents : List[str]
+            iter_halucination: int
+            lead: str
+
+        ### Nodes
+
+        def retrieve(state):
+            """
+            Retrieve documents from vectorstore
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                state (dict): New key added to state, documents, that contains retrieved documents
+            """
+            print("---RETRIEVE from Vector Store DB---")
+            question = state["question"]
+            # Retrieval
+            documents = self.retriever().invoke(question)
+            return {"documents": documents, "question": question}
+
+        def generate(state):
+            """
+            Generate answer using RAG on retrieved documents
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                state (dict): New key added to state, generation, that contains LLM generation
+            """
+            print("---GENERATE Answer---")
+            question = state["question"]
+            documents = state["documents"]
+            lead = state["lead"]
+            
+            # RAG generation
+            generation = self.main_prompt().invoke({"context": documents, "question": question, "history": self.memory, "lead": lead})
+            return {"documents": documents, "question": question, "generation": generation}
+
+        def history_router(state):
+
+            question = state["question"]
+            history_log = DatabaseOperations.question_history_search(client=self.client, 
+                                            collection_name=self.collection_name_manual,
+                                            car_id=self.CAR_ID, 
+                                            question=question, embeddings=self.embeddings)
+            
+            if len(history_log) > 0:
+                print("---ANSWER FROM HISTORY---")
+                return 'question history'
+
+            else: 
+                print("---ANSWER FROM MANUAL---")
+                return 'user manual'
+            
+        def generate_from_history(state):
+            # sohbet devamlılığı için history'den konuşmayı memory'e ekle
+            question = state["question"]
+            history_log = DatabaseOperations.question_history_search(client=self.client, 
+                                            collection_name=self.collection_name_manual,
+                                            car_id=self.CAR_ID,  
+                                            question=question, embeddings=self.embeddings)
+            return {"generation": {"text": history_log[0].payload["answer"]}}
+
+        def grade_documents(state):
+            """
+            Determines whether the retrieved documents are relevant to the question
+            If any document is not relevant, we will set a flag to run web search
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                state (dict): Filtered out irrelevant documents and updated web_search state
+            """
+
+            print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
+            question = state["question"]
+            documents = state["documents"]
+            # Score each doc
+            filtered_docs = []
+            web_search = "No"
+            for d in documents:
+                score = self.grade_documents().invoke({"question": question, "document": d.page_content})
+                grade = score.binary_score
+                # Document relevant
+                if grade.lower() == "yes":
+                    print("---GRADE: DOCUMENT RELEVANT---")
+                    filtered_docs.append(d)
+                # Document not relevant
+                else:
+                    print("---GRADE: DOCUMENT NOT RELEVANT---")
+                    # We do not include the document in filtered_docs
+                    # We set a flag to indicate that we want to run web search
+                    # web_search = "Yes"
+                    continue
+            if filtered_docs == []:
+                web_search = "Yes"
+                    
+            return {"documents": filtered_docs, "question": question, "web_search": web_search}
+
+        def grade_service(state):
+            hizmet_listesi = hizmet_listesi = {"Bakım": """Check-Up, Periyodik Bakım, Aks Değişimi, Amortisör Değişimi, Amortisör Takozu Değişimi, Baskı Balata Değişimi, Benzin Filtresi Değişimi,
+            Debriyaj Balatası Değişimi, Direksiyon Kutusu Değişimi, Dizel Araç Bakımı, Egzoz Muayenesi, Fren Kaliperi Değişimi, El Freni Teli Değişimi,
+            Fren Balatası Değişimi, Fren Disk Değişimi, Hava Filtresi Değişimi, Helezon Yay Değişimi, Kampana Fren Balatası Değişimi, 
+            Kızdırma Bujisi Değişimi, Rot Başı Değişimi, Rot Kolu Değişimi, Rotil Değişimi, Silecek Değişimi, Süspansiyon, Triger Kayışı Değişimi,
+            Triger Zinciri Değişimi, V Kayışı Değişimi, Yağ Filtresi Değişimi, Yakıt Filtresi Değişimi,""",
+                            "Yağ ve Sıvılar": """Şanzıman Yağı Değişimi, Dizel Araçlarda Yağ Değişimi, Yağ Değişimi, Fren Hidrolik Değişimi, Antifriz Değişimi,""",
+                            "Akü": """Akü Şarj Etme, Akü Değişimi""",
+                            "Klima": """Oto Klima Kompresörü Tamiri, Oto Klima Tamiri, Araç Klima Temizliği, Araç Klima Bakteri Temizliği, Klima Gazı Dolumu, Klima Dezenfeksiyonu, Polen Filtresi Değişimi""",
+                            "Elektrik": """Servis Uyarı Lambası Sıfırlama,Buji Kablosu Değişimi, Arıza Tespit, Göstergelerin Kontrolü, Far Ayarı ve Ampul Değişimi, Buji Değişimi, Sigorta Değişimi""",
+                            "Lastik/ Jant": """Lastik Jant Satış, Lastik Değişimi, Balans Ayarı, Rot Ayarı, Rotasyon, Lastik Tamiri, Hava Kontrolü, Nitrojen Dolumu, Supap Değişimi, Lastik Saklama (Lastik Oteli), Jant Sökme Takma,""",
+                            "Diğer": """Cam Tamiri""",
+                            "Hibrit Araçlar": "Hibrit Araç Aküsü"}
+            
+            print("---CHECK SERVICE RELEVANCE TO QUESTION---")
+            question = state["question"]
+            score = self.lead_check().invoke({"hizmet_listesi": hizmet_listesi, "question": question})
+            grade = score.binary_score
+            lead = 'Always use "XXX Servisi" only instead of "Yetkili Servis" or "Yetkili Bayi".'
+            
+            # Document relevant
+            if grade.lower() == "yes":
+                print("---GRADE: SERVICE RELEVANT---")
+                lead = 'Always use "Otobakım Servisi" only instead of "Toyota Servisi", "Yetkili Servis" or "Toyota Bayisi". At the end of the answer, offer the user to visit Otobakım shops for quick and affordable solutions, starting with the phrase: "If you are not sure how to proceed.".'
+            # Document not relevant
+            else:
+                print("---GRADE: SERVICE NOT RELEVANT---")
+
+            return {"lead": lead}
+            
+        def web_search(state):
+            """
+            Web search based based on the question
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                state (dict): Appended web results to documents
+            """
+
+            print("---WEB SEARCH. Append to vector store db---")
+            question = state["question"]
+            documents = state["documents"]
+            translated_question = self.translater().invoke({"question": question})["text"]
+
+            # Web search
+            docs = self.web_search().invoke({"query": translated_question})
+            # web_results = [d["snippet"] for d in docs]
+            # source = [d["link"] for d in docs]
+            # web_results = Document(page_content = web_results, metadata={'source': source})
+            web_results = [Document(page_content=d["snippet"], metadata={'source': d["link"]}) for d in docs]
+            # if documents is not None:
+            #     documents.append(web_results)
+            # else:
+            #     documents = [web_results]
+            if documents == []:
+                documents = web_results
+            print(documents)
+            return {"documents": documents, "question": question}
+
+            
+        def decide_to_generate(state):
+            """
+            Determines whether to generate an answer, or add web search
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                str: Binary decision for next node to call
+            """
+
+            print("---ASSESS GRADED DOCUMENTS---")
+            question = state["question"]
+            web_search = state["web_search"]
+            filtered_documents = state["documents"]
+
+            if web_search == "Yes":
+                # All documents have been filtered check_relevance
+                # We will re-generate a new query
+                print("---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, INCLUDE WEB SEARCH---")
+                return "websearch"
+            else:
+                # We have relevant documents, so generate answer
+                print("---DECISION: GENERATE---")
+                return "generate"
+
+        def hallucination_router(state):
+            print("---QUESTION CHANGING---")
+            question = 'You are hallucinating! Please change your answer by sticking to the context.'
+            iter_halucination = state["iter_halucination"]
+            iter_halucination += 1
+            return {'question': question, "iter_halucination": iter_halucination}
+
+        def grade_generation_v_documents_and_question(state):
+            """
+            Determines whether the generation is grounded in the document and answers question
+
+            Args:
+                state (dict): The current graph state
+
+            Returns:
+                str: Decision for next node to call
+            """
+            print("---CHECK HALLUCINATIONS---")
+            question = state["question"]
+            documents = state["documents"]
+            generation = state["generation"]
+            iter_halucination = state["iter_halucination"]
+            # print("Generation:", generation)
+            score = self.hallucination_grader().invoke({"documents": documents, "generation": generation})
+            grade = score.binary_score
+            # Check hallucination
+            if grade == "yes":
+                print("---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---")
+                # Check question-answering
+                print("---GRADE GENERATION vs QUESTION---")
+                score = self.answer_grader().invoke({"question": question,"generation": generation})
+                grade = score.binary_score
+                if grade == "yes":
+                    print("---DECISION: GENERATION ADDRESSES QUESTION---")
+                    return "useful"
+                else:
+                    print("---DECISION: GENERATION DOES NOT ADDRESS QUESTION---")
+                    return "not useful"
+            else:
+                if iter_halucination < 2:
+                    pprint("---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---")
+                    return "not supported"
+                else:
+                    return "not useful"
+            
+        def lead_check(answer):
+
+            if "otobakım" in answer.lower():
+                return 1
+            else: 
+                return 0
+            
+
+        def print_result(question, result):
+            output_text = f"""### Question: 
+            {question}
+            ### Answer: 
+            {result}
+            """
+            return(output_text)
+        
+        workflow = StateGraph(GraphState)
+
+        # Define the nodes
+        workflow.add_node("websearch", web_search) # web search # key: action to 0do
+        workflow.add_node("retrieve", retrieve) # retrieve
+        workflow.add_node("grade_documents", grade_documents) # grade documents
+        workflow.add_node("generate", generate) # generatae
+        workflow.add_node("hallucination_router", hallucination_router)
+        workflow.add_node("grade_service", grade_service)
+
+        # workflow.add_node("generate_from_history", generate_from_history)
+
+        workflow.add_edge("grade_service", "retrieve")
+        workflow.add_edge("websearch", "generate") #start -> end of node
+        workflow.add_edge("retrieve", "grade_documents")
+        workflow.add_edge("hallucination_router", "generate")
+
+
+        # workflow.add_edge("generate_from_history", END)
+
+        # Build graph
+        # workflow.set_conditional_entry_point(
+        #     history_router, # defined function
+        #     {
+        #         "question history": "generate_from_history", #returns of the function
+        #         "user manual": "grade_service",   #returns of the function
+        #     },
+        # )
+        workflow.set_entry_point(
+            "grade_service")
+
+        workflow.add_conditional_edges(
+            "grade_documents", # start: node
+            decide_to_generate, # defined function
+            {
+                "websearch": "websearch", #returns of the function
+                "generate": "generate",   #returns of the function
+            },
+        )
+
+        workflow.add_conditional_edges(
+            "generate", # start: node
+            grade_generation_v_documents_and_question, # defined function
+            {
+                "not supported": "hallucination_router", #returns of the function
+                "not useful": END,               #returns of the function
+                "useful": END,   #returns of the function
+            },
+        )
+
+        # Compile
+        app = workflow.compile()
+
+        return app