did some refactoring added documentation

app_gui.py

@@ -1,16 +1,27 @@
 # Import Gradio for UI, along with other necessary libraries
 import gradio as gr
 from rag_app.agents.react_agent import agent_executor
+from config import db
 # need to import the qa!
+db.create_new_session()
+
 
-# Function to add a new input to the chat history
 def add_text(history, text):
+    """Function to add a new input to the chat history
+    
+    Return: return_description
+    """
+    
     # Append the new text to the history with a placeholder for the response
     history = history + [(text, None)]
     return history, ""
 
-# Function representing the bot's response mechanism
+
 def bot(history):
+    """Function representing the bot's response mechanism
+    
+    """
+    
     # Obtain the response from the 'infer' function using the latest input
     response = infer(history[-1][0], history)
     #sources = [doc.metadata.get("source") for doc in response['source_documents']]
@@ -23,10 +34,13 @@ def bot(history):
     history[-1][1] = response['output']
     return history
 
-# Function to infer the response using the RAG model
+
 def infer(question, history):
+    """Function to infer the response using the RAG model
+    
+    """
+    
     # Use the question and history to query the RAG model
-    #result = qa({"query": question, "history": history, "question": question})
     try:
         result = agent_executor.invoke(
             {
@@ -37,6 +51,8 @@ def infer(question, history):
         return result
     except Exception:
         raise gr.Error("Model is Overloaded, Please retry later!")
+    
+
 
 # CSS styling for the Gradio interface
 css = """

config.py

@@ -0,0 +1,13 @@
+import os
+from dotenv import load_dotenv
+from rag_app.database.db_handler import DataBaseHandler
+
+load_dotenv()
+
+sqlite_file_name = os.getenv('SOURCES_CACHE')
+
+
+db = DataBaseHandler()
+
+db.create_all_tables()
+

rag_app/database/__init__.py

@@ -0,0 +1 @@
+from rag_app.database.db_handler import DataBaseHandler

rag_app/database/db_handler.py

@@ -3,182 +3,222 @@ from rag_app.database.schema import Sources
 from rag_app.utils.logger import get_console_logger
 import os
 from dotenv import load_dotenv
-
-load_dotenv()
-
-sqlite_file_name = os.getenv('SOURCES_CACHE')
-
-sqlite_url = f"sqlite:///{sqlite_file_name}"
-engine = create_engine(sqlite_url, echo=False)
-
-logger = get_console_logger("db_handler")
-
-SQLModel.metadata.create_all(engine)
-
-
-def read_one(hash_id: dict):
-    """
-    Read a single entry from the database by its hash_id.
-
-    Args:
-        hash_id (dict): Dictionary containing the hash_id to search for.
-
-    Returns:
-        Sources: The matching entry from the database, or None if no match is found.
-    """
-    with Session(engine) as session:
-        statement = select(Sources).where(Sources.hash_id == hash_id)
-        sources = session.exec(statement).first()
-        return sources
-
-
-def add_one(data: dict):
-    """
-    Add a single entry to the database.
-
-    Args:
-        data (dict): Dictionary containing the data for the new entry.
-
-    Returns:
-        Sources: The added entry, or None if the entry already exists.
-    """
-    with Session(engine) as session:
-        if session.exec(
-            select(Sources).where(Sources.hash_id == data.get("hash_id"))
-        ).first():
-            logger.warning(f"Item with hash_id {data.get('hash_id')} already exists")
-            return None  # or raise an exception, or handle as needed
-        sources = Sources(**data)
-        session.add(sources)
-        session.commit()
-        session.refresh(sources)
-        logger.info(f"Item with hash_id {data.get('hash_id')} added to the database")
-        return sources
-
-
-def update_one(hash_id: dict, data: dict):
-    """
-    Update a single entry in the database by its hash_id.
-
-    Args:
-        hash_id (dict): Dictionary containing the hash_id to search for.
-        data (dict): Dictionary containing the updated data for the entry.
-
-    Returns:
-        Sources: The updated entry, or None if no match is found.
-    """
-    with Session(engine) as session:
-        # Check if the item with the given hash_id exists
-        sources = session.exec(
-            select(Sources).where(Sources.hash_id == hash_id)
-        ).first()
-        if not sources:
-            logger.warning(f"No item with hash_id {hash_id} found for update")
-            return None  # or raise an exception, or handle as needed
-        for key, value in data.items():
-            setattr(sources, key, value)
-        session.commit()
-        logger.info(f"Item with hash_id {hash_id} updated in the database")
-        return sources
-
-
-def delete_one(id: int):
-    """
-    Delete a single entry from the database by its id.
-
-    Args:
-        id (int): The id of the entry to delete.
-
-    Returns:
-        None
-    """
-    with Session(engine) as session:
-        # Check if the item with the given hash_id exists
-        sources = session.exec(
-            select(Sources).where(Sources.hash_id == id)
-        ).first()
-        if not sources:
-            logger.warning(f"No item with hash_id {id} found for deletion")
-            return None  # or raise an exception, or handle as needed
-        session.delete(sources)
-        session.commit()
-        logger.info(f"Item with hash_id {id} deleted from the database")
-
-
-def add_many(data: list):
-    """
-    Add multiple entries to the database.
-
-    Args:
-        data (list): List of dictionaries, each containing the data for a new entry.
-
-    Returns:
-        None
-    """
-    with Session(engine) as session:
-        for info in data:
-            # Reuse add_one function for each item
-            result = add_one(info)
-            if result is None:
-                logger.warning(
-                    f"Item with hash_id {info.get('hash_id')} could not be added"
-                )
-            else:
-                logger.info(
-                    f"Item with hash_id {info.get('hash_id')} added to the database"
+import uuid
+from datetime import datetime
+
+
+class DataBaseHandler(): 
+    """
+    A class for managing the database.
+
+    Attributes:
+        sqlite_file_name (str): The SQLite file name for the database.
+        logger (Logger): The logger for logging database operations.
+        engine (Engine): The SQLAlchemy engine for the database.
+
+    Methods:
+        create_all_tables: Create all tables in the database.
+        read_one: Read a single entry from the database by its hash_id.
+        add_one: Add a single entry to the database.
+        update_one: Update a single entry in the database by its hash_id.
+        delete_one: Delete a single entry from the database by its id.
+        add_many: Add multiple entries to the database.
+        delete_many: Delete multiple entries from the database by their ids.
+        read_all: Read all entries from the database, optionally filtered by a query.
+        delete_all: Delete all entries from the database.
+    """
+    
+    def __init__(
+        self,
+        sqlite_file_name = os.getenv('SOURCES_CACHE'),
+        logger = get_console_logger("db_handler"),
+        # *args,
+        # **kwargs,
+        ):
+        self.sqlite_file_name = sqlite_file_name
+        self.logger = logger
+        
+        sqlite_url = f"sqlite:///{self.sqlite_file_name}"
+        self.engine = create_engine(sqlite_url, echo=False)
+        
+        
+        self.session_id = str(uuid.uuid4())
+        self.session_date_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        
+    def create_all_tables(self) -> None:
+        SQLModel.metadata.create_all(self.engine)
+    
+    def create_new_session(self) -> None:
+        """creates a new session_id and date time
+        
+        """
+        self.session_id = str(uuid.uuid4())
+        self.session_date_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+
+    def read_one(self,hash_id: dict):
+        """
+        Read a single entry from the database by its hash_id.
+
+        Args:
+            hash_id (dict): Dictionary containing the hash_id to search for.
+
+        Returns:
+            Sources: The matching entry from the database, or None if no match is found.
+        """
+        with Session(self.engine) as session:
+            statement = select(Sources).where(Sources.hash_id == hash_id)
+            sources = session.exec(statement).first()
+            return sources
+
+
+    def add_one(self,data: dict):
+        """
+        Add a single entry to the database.
+
+        Args:
+            data (dict): Dictionary containing the data for the new entry.
+
+        Returns:
+            Sources: The added entry, or None if the entry already exists.
+        """
+        with Session(self.engine) as session:
+            if session.exec(
+                select(Sources).where(Sources.hash_id == data.get("hash_id"))
+            ).first():
+                self.logger.warning(f"Item with hash_id {data.get('hash_id')} already exists")
+                return None  # or raise an exception, or handle as needed
+            sources = Sources(**data)
+            session.add(sources)
+            session.commit()
+            session.refresh(sources)
+            self.logger.info(f"Item with hash_id {data.get('hash_id')} added to the database")
+            return sources
+
+
+    def update_one(self,hash_id: dict, data: dict):
+        """
+        Update a single entry in the database by its hash_id.
+
+        Args:
+            hash_id (dict): Dictionary containing the hash_id to search for.
+            data (dict): Dictionary containing the updated data for the entry.
+
+        Returns:
+            Sources: The updated entry, or None if no match is found.
+        """
+        with Session(self.engine) as session:
+            # Check if the item with the given hash_id exists
+            sources = session.exec(
+                select(Sources).where(Sources.hash_id == hash_id)
+            ).first()
+            if not sources:
+                self.logger.warning(f"No item with hash_id {hash_id} found for update")
+                return None  # or raise an exception, or handle as needed
+            for key, value in data.items():
+                setattr(sources, key, value)
+            session.commit()
+            self.logger.info(f"Item with hash_id {hash_id} updated in the database")
+            return sources
+
+
+    def delete_one(self,id: int):
+        """
+        Delete a single entry from the database by its id.
+
+        Args:
+            id (int): The id of the entry to delete.
+
+        Returns:
+            None
+        """
+        with Session(self.engine) as session:
+            # Check if the item with the given hash_id exists
+            sources = session.exec(
+                select(Sources).where(Sources.hash_id == id)
+            ).first()
+            if not sources:
+                self.logger.warning(f"No item with hash_id {id} found for deletion")
+                return None  # or raise an exception, or handle as needed
+            session.delete(sources)
+            session.commit()
+            self.logger.info(f"Item with hash_id {id} deleted from the database")
+
+
+    def add_many(self,data: list):
+        """
+        Add multiple entries to the database.
+
+        Args:
+            data (list): List of dictionaries, each containing the data for a new entry.
+
+        Returns:
+            None
+        """
+        with Session(self.engine) as session:
+            for info in data:
+                # Reuse add_one function for each item
+                result = self.add_one(info)
+                if result is None:
+                    self.logger.warning(
+                        f"Item with hash_id {info.get('hash_id')} could not be added"
+                    )
+                else:
+                    self.logger.info(
+                        f"Item with hash_id {info.get('hash_id')} added to the database"
+                    )
+            session.commit()  # Commit at the end of the loop
+
+
+    def delete_many(self,ids: list):
+        """
+        Delete multiple entries from the database by their ids.
+
+        Args:
+            ids (list): List of ids of the entries to delete.
+
+        Returns:
+            None
+        """
+        with Session(self.engine) as session:
+            for id in ids:
+                # Reuse delete_one function for each item
+                result = self.delete_one(id)
+                if result is None:
+                    self.logger.warning(f"No item with hash_id {id} found for deletion")
+                else:
+                    self.logger.info(f"Item with hash_id {id} deleted from the database")
+            session.commit()  # Commit at the end of the loop
+
+
+    def read_all(self,query: dict = None):
+        """
+        Read all entries from the database, optionally filtered by a query.
+
+        Args:
+            query (dict, optional): Dictionary containing the query parameters. Defaults to None.
+
+        Returns:
+            list: List of matching entries from the database.
+        """
+        with Session(self.engine) as session:
+            statement = select(Sources)
+            if query:
+                statement = statement.where(
+                    *[getattr(Sources, key) == value for key, value in query.items()]
                 )
-        session.commit()  # Commit at the end of the loop
+            sources = session.exec(statement).all()
+            return sources
 
 
-def delete_many(ids: list):
-    """
-    Delete multiple entries from the database by their ids.
-
-    Args:
-        ids (list): List of ids of the entries to delete.
+    def delete_all(self,):
+        """
+        Delete all entries from the database.
 
-    Returns:
-        None
-    """
-    with Session(engine) as session:
-        for id in ids:
-            # Reuse delete_one function for each item
-            result = delete_one(id)
-            if result is None:
-                logger.warning(f"No item with hash_id {id} found for deletion")
-            else:
-                logger.info(f"Item with hash_id {id} deleted from the database")
-        session.commit()  # Commit at the end of the loop
-
-
-def read_all(query: dict = None):
-    """
-    Read all entries from the database, optionally filtered by a query.
-
-    Args:
-        query (dict, optional): Dictionary containing the query parameters. Defaults to None.
-
-    Returns:
-        list: List of matching entries from the database.
-    """
-    with Session(engine) as session:
-        statement = select(Sources)
-        if query:
-            statement = statement.where(
-                *[getattr(Sources, key) == value for key, value in query.items()]
-            )
-        sources = session.exec(statement).all()
-        return sources
-
-
-def delete_all():
-    """
-    Delete all entries from the database.
-
-    Returns:
-        None
-    """
-    with Session(engine) as session:
-        session.exec(Sources).delete()
-        session.commit()
-        logger.info("All items deleted from the database")
+        Returns:
+            None
+        """
+        with Session(self.engine) as session:
+            session.exec(Sources).delete()
+            session.commit()
+            self.logger.info("All items deleted from the database")

rag_app/database/schema.py

@@ -5,7 +5,7 @@ import datetime
 class Sources(SQLModel, table=True):
     """
     Database schema for the Sources table.
-    
+
     Attributes:
         id (Optional[int]): The primary key for the table.
         url (str): The URL of the source.
@@ -14,6 +14,8 @@ class Sources(SQLModel, table=True):
         created_at (float): Timestamp indicating when the entry was created.
         summary (str): A summary of the source content.
         embedded (bool): Flag indicating whether the source is embedded.
+        session_id (str): A unique identifier for the session when the entry was added.
+        session_date_time (str): The timestamp when the session was created.
     """
     id: Optional[int] = Field(default=None, primary_key=True)
     url: str = Field()
@@ -22,5 +24,7 @@ class Sources(SQLModel, table=True):
     created_at: float = Field(default=datetime.datetime.now().timestamp())
     summary: str = Field(default="")
     embedded: bool = Field(default=False)
+    session_id: str = Field(default="")
+    session_date_time: str = Field(default="")
 
     __table_args__ = {"extend_existing": True}

rag_app/structured_tools/agent_tools.py

@@ -20,12 +20,12 @@ def web_research(query: str) -> List[dict]:
 def ask_user(query: str) -> str:
     """Frage den Benutzer direkt wenn du nicht sicher bist was er meint oder du eine Entscheidung brauchst."""
     
-    result = HumanInputRun.invoke(query)
+    result = HumanInputRun().invoke(query)
     return result
 
 @tool
 def get_email(query: str) -> str:
     """Frage den Benutzer nach seiner EMail Adresse, wenn du denkst du hast seine Anfrage beantwortet hast, damit wir ihm mehr Informationen im Anschluss zu senden kannst."""
 
-    result = HumanInputRun.invoke(query)
+    result = HumanInputRun().invoke(query)
     return result

rag_app/structured_tools/structured_tools.py

@@ -1,25 +1,17 @@
-from langchain.tools import BaseTool, StructuredTool, tool
-from langchain_community.tools import WikipediaQueryRun
-from langchain_community.utilities import WikipediaAPIWrapper
-#from langchain.tools import Tool
+from langchain.tools import tool
 from langchain_google_community import GoogleSearchAPIWrapper
 from langchain_community.embeddings.sentence_transformer import (
     SentenceTransformerEmbeddings,
 )
 from langchain_community.vectorstores import Chroma
-import ast
-
-import chromadb
-
 from rag_app.utils.utils import (
     parse_list_to_dicts, format_search_results
 )
-from rag_app.database.db_handler import (
-    add_many
-)
-
+import chromadb
 import os
-# from innovation_pathfinder_ai.utils import create_wikipedia_urls_from_text
+from config import db
+
+
 
 persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
 embedding_model = os.getenv("EMBEDDING_MODEL")
@@ -49,6 +41,7 @@ def memory_search(query:str) -> str:
     retriever = vector_db.as_retriever()
     docs = retriever.invoke(query)
     
+    
     return docs.__str__()
 
 @tool
@@ -91,8 +84,8 @@ def google_search(query: str) -> str:
     if len(search_results)>1:
         cleaner_sources =format_search_results(search_results)
         parsed_csources = parse_list_to_dicts(cleaner_sources)
-        add_many(parsed_csources)
+        db.add_many(parsed_csources)
     else:
         cleaner_sources = search_results
     
-    return cleaner_sources.__str__()
+    return cleaner_sources.__str__()