v1

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "api:api", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,9 @@
 ---
-title: Trykopy
-emoji: 📈
-colorFrom: gray
-colorTo: yellow
+title: Try kopy
+emoji: 💻📚🤖
+colorFrom: blue
+colorTo: gray
 sdk: docker
 pinned: false
 license: agpl-3.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent/Agent.py

@@ -0,0 +1,14 @@
+from langchain.embeddings import CacheBackedEmbeddings
+from langchain.storage import LocalFileStore
+from langchain_core.language_models import BaseChatModel
+
+from emdedd.Embedding import Embedding
+
+
+class Agent:
+    embedding: Embedding
+    llm: BaseChatModel
+
+    def __init__(self, embedding, llm):
+        self.embedding = embedding
+        self.llm = llm

agent/agents.py

@@ -0,0 +1,60 @@
+import os
+
+from dotenv import load_dotenv
+from langchain_cohere.llms import Cohere
+from langchain_community.chat_models import ChatDeepInfra
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+from langchain_together import ChatTogether
+
+load_dotenv()
+
+
+def chat_openai_llm():
+    return ChatOpenAI(
+        model_name="gpt-4o",
+        temperature=os.environ["temperature"],
+        openai_api_key=os.environ["OPENAI_API_KEY"],
+        openai_organization=os.environ["OPENAI_ORGANIZATION_ID"]
+    )
+
+
+def groq_chat(model: str):
+    return ChatGroq(
+        model_name=model,
+        temperature=os.environ["temperature"],
+        groq_api_key=os.environ["GROQ_API_KEY"],
+        max_tokens=2000
+    )
+
+
+def cohere_llm():
+    return Cohere(
+        model="command-r-plus",
+        max_tokens=2048,
+        temperature=os.environ["temperature"],
+        # p=os.environ["top_p"],
+        # frequency_penalty=os.environ["frequency_penalty"],
+    )
+
+
+def together_ai_chat(model, temperature):
+    return ChatTogether(
+        model_name=model,
+        together_api_key=os.environ["TOGETHER_AI_API_KEY"],
+        temperature=temperature,
+        top_p=os.environ["top_p"],
+        max_tokens=4096,
+        model_kwargs={"stop": ["%%%%"]},
+    )
+
+
+def deepinfra_chat(model, temperature):
+    return ChatDeepInfra(
+        model=model,
+        deepinfra_api_token=os.environ["DEEPINFRA_API_KEY"],
+        temperature=temperature,
+        top_p=os.environ["top_p"],
+        max_tokens=4096,
+        model_kwargs={"stop": ["%%%%"]},
+    )

api.py

@@ -0,0 +1,88 @@
+from fastapi import FastAPI, Response, Body, Security
+from fastapi.security import APIKeyHeader
+
+from conversation.conversation_store import ConversationStore
+from rag_langchain import LangChainRAG
+
+api = FastAPI()
+
+conversation_store = ConversationStore()
+
+api_key_header = APIKeyHeader(name="Authorization", auto_error=True)
+prompt_id = "summarize_rag_1"
+check_prompt_id = "check_control_challenge_step_back"
+rewrite_prompt_id = "first"
+default_llm = "gpt-4o 128k"
+
+
+@api.get("/")
+def read_root():
+    return "Empty"
+
+
+@api.post("/q")
+async def q(api_key: str = Security(api_key_header), json_body: dict = Body(...)):
+    # Verify the API key
+    if not valid_api_key(api_key):
+        return Response(status_code=401)
+
+    # Process the JSON body
+    data = json_body
+
+    rag = LangChainRAG(
+        config={
+            "retrieve_documents": data["retrieval_count"],
+            "temperature": data["temperature"],
+            "prompt_id": prompt_id,
+            "check_prompt_id": check_prompt_id,
+            "rewrite_prompt_id": rewrite_prompt_id
+        }
+    )
+
+    answer, check_result, sources = rag.rag_chain(data["q"], default_llm)
+
+    oid = conversation_store.save_content(
+        q=q,
+        a=answer,
+        sources=list(map(lambda doc: doc.page_content, sources)),
+        params=
+        {
+            "prompt_id": prompt_id,
+            "check_prompt_id": check_prompt_id,
+            "rewrite_prompt_id": rewrite_prompt_id,
+            "check_result": check_result,
+            "temperature": data["temperature"],
+            "retrieve_document_count": data["retrieval_count"],
+        }
+    )
+
+    return Response(
+        status_code=200,
+        content={
+            "response": answer,
+            "sources": list(map(lambda doc: doc.page_content, sources)),
+            "qid": oid
+        }
+    )
+
+
+@api.post("/emo")
+async def emo(api_key: str = Security(api_key_header), json_body: dict = Body(...)):
+    # Verify the API key
+    if not valid_api_key(api_key):
+        return Response(status_code=401)
+
+    qa = conversation_store.get(json_body["qid"])
+    new_params = qa.params
+    new_params["user_grading"] = str(json_body["helpfulness"])
+    conversation_store.update(
+        oid=json_body["qid"],
+        q=qa.conversation[0].q,
+        a=qa.conversation[0].a,
+        sources=qa.conversation[0].sources,
+        params=new_params
+    )
+
+
+def valid_api_key(api_key: str):
+    return api_key == "your_secret_api_key"

conversation/conversation_store.py

@@ -0,0 +1,94 @@
+import os
+
+from dotenv import load_dotenv
+from pymongo import MongoClient
+
+from dto.conversation import Conversation, OneShotConversation
+
+load_dotenv()
+
+
+class ConversationStorage:
+
+    def __init__(self, db_uri, db_name, collection_name):
+        self.client = MongoClient(db_uri)
+        self.collection = self.client[db_name][collection_name]
+
+    def store_document_mongodb(self, conversation):
+        return self.collection.insert_one(conversation.model_dump()).inserted_id
+
+    def get_all(self):
+        docs = []
+        for q in self.collection.find():
+            docs.append(Conversation(**q))
+        return docs
+
+    def get_next(self, offset):
+        q = self.collection.find().limit(1).skip(offset)[0]
+        document = Conversation(**q)
+        print("Got {} stored at ".format(document.name, document.created))
+        return document
+
+    def get_one(self, oid) -> Conversation:
+        q = self.collection.find({"_id": oid})[0]
+        document = Conversation(**q)
+        print("Got {} stored at ".format(document.name, document.created))
+        return document
+
+    def count(self):
+        return self.collection.estimated_document_count()
+
+    def update(self, oid, conversation):
+        self.collection.update_one(
+            filter={"_id": oid},
+            update=conversation.model_dump()
+        )
+
+
+class ConversationStore:
+    URI = os.environ["DB_CONN_LOG"]
+    DB_NAME = os.environ["MONGODB_DB_NAME_MSG_LOG"]
+    COLLECTION_NAME = os.environ["MONGODB_COL_NAME_MSG_LOG"]
+
+    storage = ConversationStorage(URI, DB_NAME, COLLECTION_NAME)
+
+    def save_content(self, q, a=None, sources: list[str] = None, params: dict[str, str] = None):
+        return self.storage.store_document_mongodb(
+            Conversation(
+                conversation=[
+                    OneShotConversation(
+                        q=q,
+                        a=a,
+                        sources=sources
+                    )
+                ],
+                params=params
+            )
+        )
+
+    def get_all(self):
+        return self.storage.get_all()
+
+    def get_one(self, offset):
+        return self.storage.get_next(offset)
+
+    def get(self, oid: str) -> Conversation:
+        return self.storage.get_one(oid)
+
+    def count(self):
+        return self.storage.count()
+
+    def update(self, oid, q, a, sources, params):
+        self.storage.update(
+            oid,
+            Conversation(
+                conversation=[
+                    OneShotConversation(
+                        q=q,
+                        a=a,
+                        sources=sources
+                    )
+                ],
+                params=params
+            )
+        )

dto/conversation.py

@@ -0,0 +1,18 @@
+import uuid
+from datetime import datetime
+from typing import Optional, Annotated
+
+from pydantic import BaseModel, Field, BeforeValidator
+
+
+class OneShotConversation(BaseModel):
+    q: str = Field()
+    a: str = Field()
+    sources: list[str] = Field()
+
+
+class Conversation(BaseModel):
+    id: Optional[Annotated[str, BeforeValidator(str)]] = Field(alias="_id", default=None)
+    created: datetime = Field(default_factory=datetime.now)
+    conversation: list[OneShotConversation] = Field()
+    params: dict[str, str] = Field()

dto/document.py

@@ -0,0 +1,11 @@
+import uuid
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+
+class Document(BaseModel):
+    id: str = Field(default_factory=uuid.uuid4, alias="_id")
+    name: str = Field()
+    text: str = Field()
+    created: str = Field(default_factory=datetime.now)

dto/prompt.py

@@ -0,0 +1,12 @@
+import uuid
+from typing import Optional, Annotated
+
+from bson import ObjectId
+from pydantic import BaseModel, Field, BeforeValidator
+
+
+class Prompt(BaseModel):
+    id: Optional[Annotated[str, BeforeValidator(str)]] = Field(alias="_id", default=None)
+    name: str = Field()
+    text: str = Field()
+    prompt_type: str = Field()

emdedd/ChromaEmbedding.py

@@ -0,0 +1,28 @@
+from langchain_community.vectorstores.chroma import Chroma
+
+from emdedd.Embedding import Embedding
+
+
+class ChromaEmbedding(Embedding):
+    db: Chroma
+
+    def __init__(self, embedding, path, collection, collection_metadata = None):
+        self.db = Chroma(
+            embedding_function=embedding,
+            persist_directory=path,
+            collection_name=collection,
+            collection_metadata=collection_metadata
+        )
+
+    def embedd(self, chunks, metadata: list[dict] = None):
+        self.__store_embeddings(chunks, metadata)
+
+    def __store_embeddings(self, chunks, metadata: list[dict] = None):
+        self.db.add_texts(
+            texts=chunks,
+            metadatas=metadata
+        )
+        self.db.persist()
+
+    def get_vector_store(self):
+        return self.db

emdedd/Embedding.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class EmbeddingDbConnection:
+    connection: str
+    database: str
+    collection: str
+    index: str
+
+
+class Embedding:
+    def embedd(self, chunks, metadata: list[dict] = None):
+        pass
+
+    def get_vector_store(self):
+        pass
+
+    def search(self, query, search_type, doc_count):
+        pass

emdedd/MongoEmbedding.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+
+from langchain.embeddings import CacheBackedEmbeddings
+from langchain.storage import LocalFileStore
+from langchain_community.vectorstores.mongodb_atlas import MongoDBAtlasVectorSearch
+from langchain_core.embeddings import Embeddings
+from langchain_core.stores import InMemoryStore
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+
+from emdedd.Embedding import Embedding
+
+
+@dataclass
+class EmbeddingDbConnection:
+    connection: str
+    database: str
+    collection: str
+    index: str
+
+
+class MongoEmbedding(Embedding):
+    db: EmbeddingDbConnection
+    embedding: Embeddings
+
+    def __init__(self, db, embedding, cache: bool = True):
+        self.db = db
+        if cache:
+            self.embedding = CacheBackedEmbeddings.from_bytes_store(
+                underlying_embeddings=embedding,
+                document_embedding_cache=InMemoryStore(),
+                namespace="mongo-embedding-cache"
+            )
+        else:
+            self.embedding = embedding
+
+    def embedd(self, chunks, metadata: list[dict] = None):
+        self.__store_embeddings(chunks, metadata)
+
+    def __store_embeddings(self, chunks, metadata: list[dict] = None):
+        client = MongoClient(self.db.connection)
+        collection = client[self.db.database][self.db.collection]
+
+        # collection.create_search_index(
+        #     {"definition":
+        #          {"mappings": {"dynamic": True, "fields": {
+        #              "embedding": {
+        #                  "dimensions": 1536,
+        #                  "similarity": "cosine",
+        #                  "type": "knnVector"
+        #              }}}},
+        #      "name": self.MONGODB_INDEX_NAME
+        #      }
+        # )
+
+        MongoDBAtlasVectorSearch.from_texts(
+            texts=chunks,
+            metadatas=metadata,
+            embedding=self.embedding,
+            collection=collection,
+            index_name=self.db.index
+        )
+
+        self.__add_id_to_metadata(collection)
+
+    def __add_id_to_metadata(self, collection):
+        for document in collection.find({"metadata.id": {"$exists": "false"}}):
+            metadata: dict = document["metadata"]
+            if metadata is None: metadata = {}
+            object_id: ObjectId = document["_id"]
+            metadata["id"] = object_id.__str__()
+            collection.update_one(
+                filter={"_id": object_id},
+                update={"metadata": metadata}
+            )
+
+    def get_vector_store(self):
+        return MongoDBAtlasVectorSearch.from_connection_string(
+            self.db.connection,
+            self.db.database + "." + self.db.collection,
+            embedding=self.embedding,
+            index_name=self.db.index
+        )
+
+    def search(self, query, search_type, doc_count):
+        vector_store = self.get_vector_store()
+        retriever = vector_store.as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": doc_count}
+        )
+        return retriever.get_relevant_documents(query=query)

emdedd/Splitter.py

@@ -0,0 +1,21 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+class Splitter:
+    separators = []
+    chunk_overlap: int
+    chunk_size: int
+
+    def __init__(self, separators, chunk_overlap, chunk_size):
+        self.separators = separators
+        self.chunk_overlap = chunk_overlap
+        self.chunk_size = chunk_size
+
+    def split(self, text):
+        text_splitter = RecursiveCharacterTextSplitter(
+            separators=self.separators,
+            is_separator_regex=True,
+            chunk_overlap=self.chunk_overlap,
+            chunk_size=self.chunk_size
+        )
+        return text_splitter.split_text(text)

emdedd/embeddings.py

@@ -0,0 +1,10 @@
+from emdedd.ChromaEmbedding import ChromaEmbedding
+
+
+def chroma_embedding(name: str, embedding, metadata=None) -> ChromaEmbedding:
+    return ChromaEmbedding(
+        path="./chromadb/zpl",
+        embedding=embedding,
+        collection=name,
+        collection_metadata=metadata
+    )

prompt/prompt_store.py

@@ -0,0 +1,52 @@
+import os
+
+from dotenv import load_dotenv
+from pymongo import MongoClient
+
+from dto.prompt import Prompt
+
+load_dotenv()
+
+
+class PromptStore:
+    URI = os.environ["DB_CONN_LOG"]
+    DB_NAME = os.environ["MONGODB_DB_NAME_MSG_LOG"]
+    COLLECTION_NAME = os.environ["MONGODB_COL_NAME_PROMPT"]
+    client = MongoClient(URI)
+    collection = client[DB_NAME][COLLECTION_NAME]
+
+    def save_content(self, name, text, prompt_type):
+        self.collection.insert_one(
+            Prompt(
+                name=name,
+                text=text,
+                prompt_type=prompt_type
+            ).model_dump()
+        )
+
+    def get_all(self):
+        docs = []
+        for q in self.collection.find():
+            docs.append(Prompt(**q))
+        return docs
+
+    def get_one(self, offset) -> Prompt:
+        q = self.collection.find().limit(1).skip(offset)[0]
+        document = Prompt(**q)
+        print("Got prompt {}".format(document.name))
+        return document
+
+    def get(self, oid: str) -> Prompt:
+        q = self.collection.find({"_id": oid})[0]
+        document = Prompt(**q)
+        print("Got prompt {}".format(document.name))
+        return document
+
+    def count(self):
+        return self.collection.estimated_document_count()
+
+    def get_by_name(self, name) -> Prompt:
+        q = self.collection.find({"name": name})[0]
+        document = Prompt(**q)
+        print("Got prompt {}".format(document.name))
+        return document

rag.py

@@ -0,0 +1,400 @@
+import datetime
+import os
+import traceback
+from typing import Any
+
+from dotenv import load_dotenv
+from langchain.chains import LLMChain
+from langchain.chains.combine_documents import create_stuff_documents_chain
+from langchain.chains.retrieval import create_retrieval_chain
+from langchain.retrievers import MultiQueryRetriever, MergerRetriever, ContextualCompressionRetriever, EnsembleRetriever
+from langchain_cohere import CohereRerank
+from langchain_core.documents import Document
+from langchain_core.prompts import PromptTemplate
+
+from agent.Agent import Agent
+from agent.agents import chat_openai_llm, deepinfra_chat
+from conversation.conversation_store import ConversationStore
+from prompt.prompt_store import PromptStore
+from retrieval import retrieve, retrieve_with_rerank
+
+load_dotenv()
+
+conversation_store = ConversationStore()
+prompt_store = PromptStore()
+
+grammar_check_1 = prompt_store.get_by_name("gramar_check_1")
+rewrite_hyde_1 = prompt_store.get_by_name("rewrite_hyde_1")
+rewrite_hyde_2 = prompt_store.get_by_name("rewrite_hyde_2")
+rewrite_1 = prompt_store.get_by_name("rewrite_1")
+rewrite_2 = prompt_store.get_by_name("rewrite_2")
+rewrite_hyde = prompt_store.get_by_name("rewrite_hyde")
+
+
+def replace_nl(input: str) -> str:
+    return input.replace('\r\n', '<br>').replace('\n', '<br>').replace('\r', '<br>')
+
+
+def rag(agent: Agent, q: str, retrieve_document_count: int):
+    k = retrieve_document_count
+
+    context_doc = retrieve(agent.embedding, q, k)
+
+    prompt_template = PromptTemplate(
+        input_variables=["context", "question"],
+        template=os.environ["RAG_TEMPLATE"]
+    )
+
+    llm_chain = LLMChain(
+        llm=agent.llm,
+        prompt=prompt_template,
+        verbose=False
+    )
+
+    # llm_chain = prompt_template | agent.llm
+
+    result: dict[str, Any] = llm_chain.invoke(
+        input={
+            "question": q,
+            "context": context_doc
+        }
+    )
+
+    return result["text"]
+
+
+def rewrite(agent: Agent, q: str, prompt: str) -> list[str]:
+    prompt_template = PromptTemplate(
+        input_variables=["question"],
+        template=prompt
+    )
+    llm_chain = LLMChain(
+        llm=agent.llm,
+        prompt=prompt_template,
+        verbose=False
+    )
+    questions = llm_chain.invoke(
+        input={"question": q}
+    )["text"].splitlines()
+
+    return [x for x in questions if ("##" not in x and len(str(x).strip()) > 0)]
+
+
+def rag_with_rerank_check_rewrite(agent: Agent, q: str, retrieve_document_count: int, prompt: str, check_prompt: str,
+                                  rewrite_prompt: str):
+    rewritten_list: list[str] = rewrite(agent, q, rewrite_prompt)
+
+    if len(rewritten_list) == 0:
+        return "Neviem, nemám podklady!", "", ""
+
+    context_doc = retrieve_subqueries(agent, retrieve_document_count, rewritten_list)
+
+    if len(context_doc) == 0:
+        return "Neviem, nemám kontext!", "", ""
+
+    result = answer_pipeline(agent, context_doc, prompt, q)
+    answer = result["text"]
+
+    check_result = check_pipeline(answer, check_prompt, context_doc, q)
+
+    return answer, check_result, context_doc
+
+
+def rag_with_rerank_check_rewrite_hyde(agent: Agent, q: str, retrieve_document_count: int, prompt: str,
+                                       check_prompt: str,
+                                       rewrite_prompt: str):
+    rewritten_list: list[str] = rewrite(agent, q, rewrite_prompt)
+
+    if len(rewritten_list) == 0:
+        return "Neviem, nemám podklady!", "", ""
+
+    context_doc = retrieve_subqueries_hyde(agent, retrieve_document_count, rewritten_list)
+
+    if len(context_doc) == 0:
+        return "Neviem, nemám kontext!", "", ""
+
+    result = answer_pipeline(agent, context_doc, prompt, q)
+    answer = result["text"]
+
+    check_result = check_pipeline(answer, check_prompt, context_doc, q)
+
+    return answer, check_result, context_doc
+
+
+def rag_with_rerank_check_multi_query_retriever(agent: Agent, q: str, retrieve_document_count: int, prompt: str,
+                                                check_prompt: str):
+    context_doc = hyde_retrieval(agent, retrieve_document_count).invoke(
+        input=q,
+        kwargs={"k": retrieve_document_count}
+    )
+
+    if len(context_doc) == 0:
+        return "Neviem, nemám kontext!", "", ""
+
+    result = answer_pipeline(agent, context_doc, prompt, q)
+    answer = result["text"]
+
+    check_result = check_pipeline(answer, check_prompt, context_doc, q)
+
+    return answer, check_result, context_doc
+
+
+def rag_chain(agent: Agent, q: str, retrieve_document_count: int, prompt: str,
+              check_prompt: str):
+    result = create_retrieval_chain(
+        retriever=hyde_2_retrieval(agent, retrieve_document_count),
+        combine_docs_chain=create_stuff_documents_chain(
+            llm=agent.llm,
+            prompt=PromptTemplate(
+                input_variables=["context", "question", "actual_date"],
+                template=prompt
+            )
+        )
+    ).invoke(
+        input={
+            "question": q,
+            "input": q,
+            "actual_date": datetime.date.today().isoformat()
+        }
+    )
+
+    check_result = check_pipeline(result["answer"], check_prompt, result["context"], q)
+
+    return result["answer"], check_result, result["context"]
+
+
+def hyde_retrieval(agent, retrieve_document_count):
+    retriever_1 = MultiQueryRetriever.from_llm(
+        llm=agent.llm,
+        retriever=agent.embedding.get_vector_store().as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": retrieve_document_count}
+        ),
+        prompt=PromptTemplate(
+            input_variables=["question"],
+            template=rewrite_hyde_1
+        )
+    )
+    retriever_2 = MultiQueryRetriever.from_llm(
+        llm=agent.llm,
+        retriever=agent.embedding.get_vector_store().as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": retrieve_document_count}
+        ),
+        prompt=PromptTemplate(
+            input_variables=["question"],
+            template=rewrite_hyde_2
+        )
+    )
+    merge_retriever = MergerRetriever(
+        retrievers=[retriever_1, retriever_2],
+    )
+    compressor = CohereRerank(
+        model="rerank-multilingual-v3.0",
+        top_n=retrieve_document_count
+    )
+    compression_retriever = ContextualCompressionRetriever(
+        base_compressor=compressor,
+        base_retriever=merge_retriever,
+        search_kwargs={"k": retrieve_document_count},
+    )
+
+    return compression_retriever
+
+
+def hyde_2_retrieval(agent, retrieve_document_count):
+    compressor = CohereRerank(
+        model="rerank-multilingual-v3.0",
+        top_n=retrieve_document_count / 2
+    )
+    retriever_1 = MultiQueryRetriever.from_llm(
+        llm=agent.llm,
+        retriever=agent.embedding.get_vector_store().as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": min(retrieve_document_count * 10, 500)}
+        ),
+        prompt=PromptTemplate(
+            input_variables=["question"],
+            template=rewrite_1
+        )
+    )
+    compression_retriever_1 = ContextualCompressionRetriever(
+        base_compressor=compressor,
+        base_retriever=retriever_1
+    )
+
+    retriever_2 = MultiQueryRetriever.from_llm(
+        llm=agent.llm,
+        retriever=agent.embedding.get_vector_store().as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": min(retrieve_document_count * 10, 500)}
+        ),
+        prompt=PromptTemplate(
+            input_variables=["question"],
+            template=rewrite_2
+        )
+    )
+    compression_retriever_2 = ContextualCompressionRetriever(
+        base_compressor=compressor,
+        base_retriever=retriever_2
+    )
+
+    retriever_3 = MultiQueryRetriever.from_llm(
+        llm=agent.llm,
+        retriever=agent.embedding.get_vector_store().as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": min(retrieve_document_count * 10, 500)}
+        ),
+        prompt=PromptTemplate(
+            input_variables=["question"],
+            template=rewrite_hyde
+        )
+    )
+    compression_retriever_3 = ContextualCompressionRetriever(
+        base_compressor=compressor,
+        base_retriever=retriever_3
+    )
+
+    merge_retriever = EnsembleRetriever(
+        retrievers=[compression_retriever_1, compression_retriever_2, compression_retriever_3],
+        weights=[1.0, 1.0, 1.0]
+    )
+
+    return merge_retriever
+
+
+def retrieve_subqueries(agent, retrieve_document_count, rewritten_list) -> list[Document]:
+    contexts: list[Document] = []
+    for rewritten in rewritten_list:
+        contexts.extend(retrieve_with_rerank(agent.embedding, rewritten, retrieve_document_count))
+
+    contexts.sort(key=lambda x: -x.metadata["relevance_score"])
+
+    deduplicated: list[Document] = []
+    for doc in contexts:
+        already_in = False
+        for de_doc in deduplicated:
+            if doc.page_content == de_doc.page_content:
+                already_in = True
+        if not already_in:
+            deduplicated.append(doc)
+
+    return deduplicated[:retrieve_document_count]
+
+
+def retrieve_subqueries_hyde(agent, retrieve_document_count, rewritten_list) -> list[Document]:
+    contexts: list[Document] = []
+    for rewritten in rewritten_list:
+        answer = agent.llm.invoke(rewritten).content
+        contexts.extend(retrieve_with_rerank(agent.embedding, rewritten + "\n" + answer, retrieve_document_count))
+
+    contexts.sort(key=lambda x: -x.metadata["relevance_score"])
+
+    deduplicated: list[Document] = []
+    for doc in contexts:
+        already_in = False
+        for de_doc in deduplicated:
+            if doc.page_content == de_doc.page_content:
+                already_in = True
+        if not already_in:
+            deduplicated.append(doc)
+
+    return deduplicated[:retrieve_document_count]
+
+
+def answer_pipeline(agent, context_doc, prompt, q):
+    prompt_template = PromptTemplate(
+        input_variables=["context", "question"],
+        template=prompt
+    )
+    llm_chain = LLMChain(
+        llm=agent.llm,
+        prompt=prompt_template,
+        verbose=False
+    )
+
+    result: dict[str, Any] = llm_chain.invoke(
+        input={
+            "question": q,
+            "context": context_doc,
+            "actual_date": datetime.date.today().isoformat()
+        }
+    )
+    return result
+
+
+def check_pipeline(answer, check_prompt, context_doc, q):
+    prompt_template = PromptTemplate(
+        input_variables=["context", "question", "answer"],
+        template=check_prompt
+    )
+    llm_chain = LLMChain(
+        llm=deepinfra_chat("meta-llama/Meta-Llama-3-70B-Instruct", "0.4"),
+        prompt=prompt_template,
+        verbose=False
+    )
+    try:
+        check_result = llm_chain.invoke(
+            input={
+                "question": q[:2000],
+                "context": context_doc,
+                "answer": answer
+            }
+        )["text"]
+    except Exception as e:
+        check_result = traceback.format_exc()
+
+    return check_result
+
+
+def rag_with_rerank(agent: Agent, q: str, retrieve_document_count: int, prompt: str = None, check_prompt: str = None):
+    context_doc: list[Document] = retrieve_with_rerank(agent.embedding, q, retrieve_document_count)
+
+    try:
+        result: dict[str, Any] = answer_pipeline(agent, context_doc, prompt, q)
+
+        answer = result["text"]
+        check_result = ""
+
+        if check_prompt is not None:
+            check_result = check_pipeline(answer, check_prompt, context_doc, q)
+
+        return answer, check_result, context_doc
+    except Exception as e:
+        return "", traceback.format_exc(), ""
+
+
+def save_conversation(answer: str, check_result: str, context_doc: list[Document], gramatika: str, question: str,
+                      prompt_id: str, check_prompt_id: str, grammar_prompt_id: str):
+    if len(answer) > 0:
+        conversation_store.save_content(
+            q=question,
+            a=answer,
+            sources=list(map(lambda doc: doc.page_content, context_doc)),
+            params=
+            {
+                "prompt_id": prompt_id,
+                "check_prompt_id": check_prompt_id,
+                "grammar_prompt_id": grammar_prompt_id,
+                "check_result": check_result,
+                "grammar_result": gramatika,
+                "temperature": os.environ["temperature"],
+            }
+        )
+
+
+def check_slovak_agent(text: str) -> str:
+    prompt_template = PromptTemplate(
+        input_variables=["text"],
+        template=grammar_check_1
+    )
+
+    llm_chain = LLMChain(
+        llm=chat_openai_llm(),
+        prompt=prompt_template,
+        verbose=False
+    )
+
+    result: dict[str, Any] = llm_chain.invoke(input={"text": text})
+
+    return result["text"]

rag_langchain.py

@@ -0,0 +1,129 @@
+import os
+
+from dotenv import load_dotenv
+from gptcache import Cache
+from gptcache.manager.factory import manager_factory
+from gptcache.processor.pre import get_prompt
+from langchain.retrievers import ContextualCompressionRetriever
+from langchain_cohere import CohereRerank
+from langchain_community.cache import GPTCache
+from langchain_core.language_models import BaseChatModel
+from langchain_core.prompts import PromptTemplate
+from langchain_core.retrievers import BaseRetriever
+from langchain_google_genai import ChatGoogleGenerativeAI, HarmCategory, HarmBlockThreshold
+from langchain_openai import ChatOpenAI
+
+from agent.Agent import Agent
+from agent.agents import deepinfra_chat, \
+    together_ai_chat, groq_chat, cohere_llm
+from emdedd.Embedding import Embedding
+from emdedd.embeddings import chroma_embedding, cohere_embeddings
+from prompt.prompt_store import PromptStore
+from rag import rag_chain
+
+load_dotenv()
+
+
+class LangChainRAG:
+    embedding: tuple[Embedding]
+    llms: dict[str, BaseChatModel]
+    retriever: BaseRetriever
+    prompt_template: PromptTemplate
+    config: dict
+    semantic_cache: GPTCache
+    prompt_store = PromptStore()
+
+    def __init__(self, config):
+        self.config = config
+        self.semantic_cache = GPTCache(_init_gptcache)
+        self.embedding = MongoEmbedding(
+            db=EmbeddingDbConnection(
+                connection=os.environ["DB_CONN_EMBED"],
+                database=os.environ["MONGODB_DB_NAME_ZPL_EMBED"],
+                collection="zpl-2402-cohere",
+                index="knnVector-cosine-index"
+            ),
+            embedding=CohereEmbeddings(model="embed-multilingual-v3.0")
+        )
+
+        self.llms = {
+            "gpt-4o 128k": ChatOpenAI(
+                model_name="gpt-4o",
+                temperature=config["temperature"],
+                openai_api_key=os.environ["OPENAI_API_KEY"],
+                openai_organization=os.environ["OPENAI_ORGANIZATION_ID"]
+            ),
+            "llama-3 70B deepinfra 8k": deepinfra_chat("meta-llama/Meta-Llama-3-70B-Instruct",
+                                                       self.config["temperature"]),
+            "llama-3 8B deepinfra 8k": deepinfra_chat("meta-llama/Meta-Llama-3-8B-Instruct",
+                                                      self.config["temperature"]),
+            "Mixtral-8x22B-Instruct-v0.1 deepinfra 32k": deepinfra_chat("mistralai/Mixtral-8x22B-Instruct-v0.1",
+                                                                        self.config["temperature"]),
+            "gemini-pro 128k": ChatGoogleGenerativeAI(
+                model="gemini-pro",
+                convert_system_message_to_human=True,
+                safety_settings={
+                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_DEROGATORY: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE,
+                },
+                transport="rest",
+                stopSequence=["%%%%"],
+                temperature=config["temperature"],
+                cache=self.semantic_cache
+            ),
+            "Mistral (7B) Instruct v0.3 together.ai 32k": together_ai_chat(
+                model="mistralai/Mistral-7B-Instruct-v0.3",
+                temperature=config["temperature"]
+            ),
+            "OpenHermes-2.5 Mistral 7B together.ai 32k": together_ai_chat(
+                model="teknium/OpenHermes-2p5-Mistral-7B",
+                temperature=config["temperature"]
+            ),
+            "chat_groq_llm": groq_chat("mixtral-8x7b-32768"),
+            "chat_groq_llama3_70": groq_chat("llama3-70b-8192"),
+            "command_r_plus": cohere_llm(),
+
+        }
+
+        self.retriever = ContextualCompressionRetriever(
+            base_compressor=CohereRerank(model="rerank-multilingual-v3.0", top_n=os.getenv("retrieve_documents")),
+            base_retriever=self.get_vector_store_mongodb().as_retriever(
+                search_type="similarity",
+                search_kwargs={"k": config["retrieve_documents"] * 10}
+            )
+        )
+
+    def get_vector_store_mongodb(self):
+        return self.embedding[0].get_vector_store()
+
+    def get_llms(self):
+        return self.llms.keys()
+
+    def rag_chain(self, query, choice):
+        # answer, check_result, context_doc = rag_with_rerank_check_rewrite(
+        # answer, check_result, context_doc = rag_with_rerank_check_rewrite_hyde(
+        # answer, check_result, context_doc = rag_with_rerank_check_multi_query_retriever(
+        answer, check_result, context_doc = rag_chain(
+            Agent(embedding=self.embedding[0], llm=self.llms[choice]),
+            query,
+            self.config["retrieve_documents"],
+            self.prompt_store.get_by_name(self.config["prompt_id"]).text,
+            self.prompt_store.get_by_name(self.config["check_prompt_id"]).text
+        )
+
+        return answer, check_result, context_doc
+
+
+def _init_gptcache(cache_obj: Cache, llm: str):
+    cache_obj.init(
+        pre_embedding_func=get_prompt,
+        data_manager=manager_factory(data_dir=f"map_cache"),
+        # data_manager=get_data_manager(
+        #     cache_base=CacheBase("mongo", url="mongodb://localhost:27017/"),
+        #     vector_base=Chromadb(
+        #         persist_directory="./chromadb/cache",
+        #     ),
+        # )
+    )

requirements.txt

@@ -0,0 +1,26 @@
+langchain
+langchain-community
+langchain-openai
+langchain-groq
+langchain-mistralai
+langchain-cohere
+langchain-google-genai
+langchain-together
+
+fitz
+pypdf
+tools
+python-dotenv
+pymongo
+pydantic
+chromadb
+bs4
+fastapi
+gptcache
+
+fastapi
+requests
+uvicorn[standard]
+
+sentence-transformers
+text_generation

retrieval.py

@@ -0,0 +1,110 @@
+import datetime
+
+from langchain.retrievers import ContextualCompressionRetriever
+from langchain_cohere.rerank import CohereRerank
+from langchain_core.vectorstores import VectorStoreRetriever
+
+from emdedd.Embedding import Embedding
+from emdedd.embeddings import embed_zakonnik_prace
+from questions import questions
+
+
+def retrieve(embedding, q, retrieve_document_count):
+    retriever: VectorStoreRetriever = embedding.get_vector_store().as_retriever(
+        search_type="similarity",
+        search_kwargs={"k": retrieve_document_count}
+    )
+
+    context_doc = retriever.get_relevant_documents(
+        query=q,
+        kwargs={"k": retrieve_document_count}
+    )
+
+    return context_doc
+
+
+def retrieve_with_rerank(embedding, q, retrieve_document_count):
+    compression_retriever = reranking_retriever(embedding, retrieve_document_count)
+
+    context_doc = compression_retriever.invoke(
+        input=q,
+        kwargs={"k": retrieve_document_count}
+    )
+
+    # for doc in context_doc:
+    #     text = doc.page_content
+    #     print("    kontext: " + text.replace('\n', ' ').replace('\r', ' '))
+
+    return context_doc
+
+
+def reranking_retriever(embedding, retrieve_document_count):
+    retriever: VectorStoreRetriever = embedding.get_vector_store().as_retriever(
+        search_type="similarity",
+        search_kwargs={"k": retrieve_document_count * 10}
+    )
+    compressor = CohereRerank(model="rerank-multilingual-v3.0")
+    compression_retriever = ContextualCompressionRetriever(
+        base_compressor=compressor, base_retriever=retriever
+    )
+    return compression_retriever
+
+
+#     todo
+# def hyde(agent: Agent, q, retrieve_document_count):
+#     retriever: VectorStoreRetriever = agent.embedding.get_vector_store().as_retriever(
+#         search_type="similarity",
+#         search_kwargs={"k": retrieve_document_count * 10}
+#     )
+
+    #
+    # context_doc = compression_retriever.get_relevant_documents(
+    #     query=q,
+    #     kwargs={"k": retrieve_document_count}
+    # )
+    #
+    # for doc in context_doc:
+    #     text = doc.page_content
+    #     print("    kontext: " + text.replace('\n', ' ').replace('\r', ' '))
+    #
+    # return context_doc
+
+
+def retrieve_test(name: str, embed_dict: dict[str, Embedding], emded: bool = False):
+    try:
+        result_file = open(name + "_retrieve_test.md", "a")
+        for embed_key, embedding in embed_dict.items():
+            if emded:
+                embed_zakonnik_prace(embedding)
+            print("--- Running on " + embed_key)
+            result_file.write("\n\n| " + embed_key + " | " + str(datetime.datetime.now()) + " |")
+            result_file.write("\n|-------|-----------|")
+            dobre: int = 0
+            for q in questions:
+                print(q)
+                context_doc = retrieve(embedding, q, 5)
+                for doc in context_doc:
+                    text = doc.page_content
+                    print("    kontext: " + text.replace('\n', ' ').replace('\r', ' '))
+                    result_file.write("\n| " + q + " | " + text.replace('\n', ' ').replace('\r', ' ') + " |")
+                    dobre = dobre + 1 if "§ 100" in text else dobre
+                    dobre = dobre + 1 if "§ 101" in text else dobre
+                    dobre = dobre + 1 if "§ 103" in text else dobre
+                    dobre = dobre + 1 if "§ 104" in text else dobre
+                    dobre = dobre + 1 if "§ 105" in text else dobre
+                    dobre = dobre + 1 if "§ 106" in text else dobre
+                    dobre = dobre + 1 if "§ 107" in text else dobre
+                    dobre = dobre + 1 if "§ 109" in text else dobre
+                    dobre = dobre + 1 if "§ 110" in text else dobre
+                    dobre = dobre + 1 if "§ 111" in text else dobre
+                    dobre = dobre + 1 if "§ 112" in text else dobre
+                    dobre = dobre + 1 if "§ 113" in text else dobre
+                    dobre = dobre + 1 if "§ 114" in text else dobre
+                    dobre = dobre + 1 if "§ 115" in text else dobre
+                    dobre = dobre + 1 if "§ 116" in text else dobre
+                    dobre = dobre + 1 if "§ 117" in text else dobre
+            result_file.write("\n| Dobre: | " + str(dobre) + " |")
+    finally:
+        result_file.write("\n\n")
+        result_file.flush()
+        result_file.close()

task_splitting.py

@@ -0,0 +1,101 @@
+import datetime
+from time import sleep
+
+from langchain.chains import LLMChain
+from langchain_core.prompts import PromptTemplate
+
+from agent.Agent import Agent
+from agent.agents import chat_groq_llama3_70
+from emdedd.embeddings import cohere_embeddings, chroma_embedding, embed_zakonnik_prace
+from promts import for_tree_llama3_rag_sub, for_tree_llama3_rag_tree, for_tree_llama3_rag_group
+from retrieval import retrieve_with_rerank
+from questions import questions
+
+
+def rag_tree(agent: Agent, q: str, retrieve_document_count: int) -> str:
+    tree_template = PromptTemplate(
+        input_variables=["context", "question"],
+        template=for_tree_llama3_rag_tree
+    )
+
+    context_doc = retrieve_with_rerank(agent.embedding, q, retrieve_document_count * 2)
+
+    sub_qs = LLMChain(
+        llm=agent.llm,
+        prompt=tree_template,
+        verbose=False
+    ).invoke(
+        input={
+            "question": q,
+            "context": context_doc
+        }
+    )["text"]
+
+    print(sub_qs)
+    sleep(60)
+
+    print("_________")
+
+    sub_template = PromptTemplate(
+        input_variables=["context", "question"],
+        template=for_tree_llama3_rag_sub
+    )
+
+    sub_answers: dict[str, str] = {}
+
+    for sub_q in sub_qs.splitlines():
+        if "?" not in sub_q: continue
+        print(sub_q)
+        sub_answers[sub_q] = LLMChain(
+            llm=agent.llm,
+            prompt=sub_template,
+            verbose=False
+        ).invoke(
+            input={
+                "question": sub_q,
+                "context": retrieve_with_rerank(agent.embedding, sub_q, retrieve_document_count)
+            }
+        )["text"]
+        print(sub_answers[sub_q])
+        sleep(60)
+
+
+    final_template = PromptTemplate(
+        input_variables=["context", "question", "subs"],
+        template=for_tree_llama3_rag_group
+    )
+
+    result = LLMChain(
+        llm=agent.llm,
+        prompt=final_template,
+        verbose=True
+    ).invoke(
+        input={
+            "question": q,
+            "context": context_doc,
+            "subs": sub_answers.items()
+        }
+    )
+
+    return result["text"]
+
+
+def tree_of_thought(name: str, agent: Agent, emded: bool = False, retrieve_document_count=5):
+    try:
+        result_file = open(name + "_test.md", "a")
+        if emded:
+            embed_zakonnik_prace(agent.embedding)
+        for q in questions:
+            print("--- Q: " + q)
+            result_file.write("\n\n| " + name + str(datetime.datetime.now()) + " | " + q + " |")
+            result_file.write("\n|-------|-----------|")
+
+            answer = rag_tree(agent, q, retrieve_document_count)
+            print(answer)
+            result_file.write(
+                "\n| tree | " + answer.replace('\r\n', '<br>').replace('\n', '<br>').replace('\r', '<br>') + " |")
+            sleep(60)
+    finally:
+        result_file.write("\n\n")
+        result_file.flush()
+        result_file.close()