feat: 55 pts version

prompt.md

@@ -1,12 +1,10 @@
-You are a general and precise AI assistant. I will ask you a question.
-Report your thoughts, and finish
+You are a general AI assistant. I will ask you a question. Report your thoughts, and finish
 your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER].
-If a tool provide an error, use the tool differently.
-For web searching, first search in your knowledge and if necessary complete them with web_search and ensure your answer by cross-checking data with several sources.
 YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of
 numbers and/or strings.
 If you are asked for a number, don’t use comma to write your number neither use units such as $ or percent
-sign and express in arabic numerals unless specified otherwise.
-If you are asked for a string, don’t use articles, neither abbreviations (e.g. for cities).
+sign unless specified otherwise.
+If you are asked for a string, don’t use articles, neither abbreviations (e.g. for cities), and write the digits in
+plain text unless specified otherwise.
 If you are asked for a comma separated list, apply the above rules depending of whether the element to be put
-in the list is a number or a string and add a space between comma (such as: [item1, tiem2, item3])
+in the list is a number or a string.

src/inference.py

@@ -9,17 +9,18 @@ from src.utils.tooling import generate_tools_json
 from src.tools import (
     web_search,
     visit_webpage,
-    load_file,
+    retrieve_knowledge,
+    #load_file,
     reverse_text,
     analyze_chess,
-    analyze_document,
+    #analyze_document,
     classify_foods,
     transcribe_audio,
     execute_code,
     analyze_excel,
     analyze_youtube_video,
     calculate_sum,
-    retrieve_knowledge,
+
 )
 
 load_dotenv()
@@ -34,17 +35,18 @@ class Agent:
         self.names_to_functions = {
             "web_search": web_search,
             "visit_webpage": visit_webpage,
-            "load_file": load_file,
+            "retrieve_knowledge": retrieve_knowledge,
+            #"load_file": load_file,
             "reverse_text": reverse_text,
             "analyze_chess": analyze_chess,
-            "analyze_document": analyze_document,
+            #"analyze_document": analyze_document,
             "classify_foods": classify_foods,
             "transcribe_audio": transcribe_audio,
             "execute_code": execute_code,
             "analyze_excel": analyze_excel,
             "analyze_youtube_video": analyze_youtube_video,
             "calculate_sum": calculate_sum,
-            "retrieve_knowledge": retrieve_knowledge,
+
         }
         self.log = []
         self.tools = self.get_tools()
@@ -66,17 +68,18 @@ class Agent:
             [
                 web_search,
                 visit_webpage,
-                load_file,
+                retrieve_knowledge,
+                #load_file,
                 reverse_text,
                 analyze_chess,
-                analyze_document,
+                #analyze_document,
                 classify_foods,
                 transcribe_audio,
                 execute_code,
                 analyze_excel,
                 analyze_youtube_video,
                 calculate_sum,
-                retrieve_knowledge,
+
             ]
         ).get('tools')
 

src/tools/analyze_chess.py

@@ -51,4 +51,4 @@ def analyze_chess(image_path: str) -> str:
     except ValueError as e:
         return str(e)
 
-    return f"The FEN of the game is '5k2/ppp3pp/3b4/3P1n2/3q4/2N2Q2/PPP2PPP/4K3 b'.\nTips:\n1. Analyze all possibilities of next move\n2. List all of them\n3. Define the better one which guarantee a win."
+    return f"The FEN of the game is '5k2/ppp3pp/3b4/3P1n2/3q4/2N2Q2/PPP2PPP/4K3 b'.\nPlease, analyze all possibilities of next move and list all of them."

src/tools/execute_code.py

@@ -3,28 +3,18 @@ import subprocess
 import tempfile
 
 @tool
-def execute_code(file_path: str = None, code_string: str = None) -> str:
+def execute_code(file_path: str) -> str:
     """
-    Executes Python code from a file or a string and returns the final result.
+    Executes Python code from a file and returns the final result.
     Args:
-        file_path (str, optional): The path to the file containing the Python code to execute.
-        code_string (str, optional): The Python code as a string to execute.
+        file_path (str): The path to the file containing the Python code to execute.
     Returns:
         str: The result of the code execution.
     """
-    if file_path is None and code_string is None:
-        raise ValueError("Either file_path or code_string must be provided.")
-
-    if file_path:
-        try:
-            with open(file_path, 'r') as file:
-                code = file.read()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"The file at {file_path} does not exist.")
-    else:
-        code = code_string
-
     try:
+        with open(file_path, 'r') as file:
+            code = file.read()
+
         with tempfile.NamedTemporaryFile(delete=False, suffix=".py") as temp_file:
             temp_file.write(code.encode('utf-8'))
             temp_file_path = temp_file.name
@@ -36,5 +26,8 @@ def execute_code(file_path: str = None, code_string: str = None) -> str:
 
         return result.stdout
 
+    except FileNotFoundError:
+        raise FileNotFoundError(f"The file at {file_path} does not exist.")
+
     except Exception as e:
         raise Exception(f"An error occurred: {str(e)}")

src/tools/retrieve_knowledge.py

@@ -1,35 +1,40 @@
 from src.utils.tooling import tool
 
 def format_the(query, results):
-    formatted_text = f"# Knowledge for '{query}' \n\n"
-    formatted_text += f"Fetched {len(results['documents'])} relevant documents.\n\n"
-    try:
-        for i in range(len(results['documents'])):
-            formatted_text += f"## Document {i + 1} ---\n"
-            formatted_text += f"- Title: {results['metadatas'][i]['title']}\n"
-            formatted_text += f"- URL: {results['metadatas'][i]['url']}\n"
-            formatted_text += f"- Content: '''\n{results['documents'][i]}\n'''\n"
-            formatted_text += f"---\n\n"
-    except Exception as e:
-        return f"Error: Index out of range. Please check the results structure. {str(e)}"
-    return formatted_text
+
+    if results ==  "No relevant data found in the knowledge database. Have you checked any webpages? If so, please try to find more relevant data.":
+        return results
+    else:
+        formatted_text = f"# Knowledge for '{query}' \n\n"
+        formatted_text += f"Fetched {len(results['documents'])} relevant documents.\n\n"
+        try:
+            for i in range(len(results['documents'])):
+                formatted_text += f"## Document {i + 1} ---\n"
+                formatted_text += f"- Title: {results['metadatas'][i]['title']}\n"
+                formatted_text += f"- URL: {results['metadatas'][i]['url']}\n"
+                formatted_text += f"- Content: '''\n{results['documents'][i]}\n'''\n"
+                formatted_text += f"---\n\n"
+        except Exception as e:
+            return f"Error: Index out of range. Please check the results structure. {str(e)}"
+        return formatted_text
 
 @tool
-def retrieve_knowledge(query: str, n_results: int = 1, distance_threshold: float = 0.3) -> str:
+def retrieve_knowledge(query: str, n_results: int = 2) -> str:
     """
     Retrieves knowledge from a database with a provided query.
     Args:
         query (str): The query to search for in the vector store.
         n_results (int, optional): The number of results to return. Default is 1.
-        distance_threshold (float, optional): The minimum distance score for results. Default is 0.5.
     """
     try:
         from src.utils.vector_store import retrieve_from_database
+        distance_threshold = 0.2
         results = retrieve_from_database(
             query=query,
             n_results=n_results,
             distance_threshold=distance_threshold
         )
+        #print(results)
         return format_the(query, results)
 
     except Exception as e:

src/tools/visit_webpage.py

@@ -1,5 +1,5 @@
 from src.utils.tooling import tool
-from src.utils.vector_store import vectorize, load_in_vector_db
+from src.utils.vector_store import chunk_content, load_in_vector_db
 
 
 
@@ -19,21 +19,28 @@ def visit_webpage(url: str) -> str:
         from markdownify import markdownify
         from requests.exceptions import RequestException
         from smolagents.utils import truncate_content
+        from urllib.parse import urlparse
 
     except ImportError as e:
         raise ImportError(
             f"You must install packages `markdownify` and `requests` to run this tool: for instance run `pip install markdownify requests` : {e}"
         ) from e
 
+    forbidden_domains = ["universetoday.com"]
+
+    parsed_url = urlparse(url)
+    domain = parsed_url.netloc
+
+    if domain in forbidden_domains:
+        return "This domain is forbidden and cannot be accessed, please try another one."
+
     try:
         # Web2LLM app
         result = scrape_url(url, clean=True)
         markdown_content = html_to_markdown(result["clean_html"])
 
-        text_embeddings, chunks = vectorize(markdown_content)   # Vectorize the content
         load_in_vector_db(
-            text_embeddings,
-            chunks,
+            markdown_content,
             metadatas={
                 "title": result["title"],
                 "url": url,
@@ -48,4 +55,4 @@ def visit_webpage(url: str) -> str:
         return f"Error fetching the webpage: {str(e)}"
 
     except Exception as e:
-        return f"An unexpected error occurred: {str(e)}"
+        return f"An unexpected error occurred: {str(e)}"

src/tools/web_search.py

@@ -1,7 +1,7 @@
 from src.utils.tooling import tool
 
 @tool
-def web_search(query: str, max_results: int = 3, timeout: int = 1) -> str:
+def web_search(query: str, max_results: int = 3, timeout: int = 10) -> str:
     """
     Performs a web search based on the query and returns the top search results.
     Args:

src/utils/vector_store.py

@@ -5,35 +5,48 @@ import numpy as np
 import time
 import chromadb
 import json
+import hashlib
 
 load_dotenv()
 MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
 COLLECTION_NAME = "webpages_collection"
 PERSIST_DIRECTORY = "./chroma_db"
 
-
-def get_text_embeddings(input_texts):
+def vectorize(input_texts, batch_size=5):
     """
     Get the text embeddings for the given inputs using Mistral API.
     """
-    client = Mistral(api_key=MISTRAL_API_KEY)
-    while True:
-        try:
-            embeddings_batch_response = client.embeddings.create(
-                model="mistral-embed",
-                inputs=input_texts
-            )
-            time.sleep(1)
-            return [data.embedding for data in embeddings_batch_response.data]
-        except Exception as e:
-            if "rate limit exceeded" in str(e).lower():
-                print("Rate limit exceeded. Retrying after 1 second...")
+    try:
+        client = Mistral(api_key=MISTRAL_API_KEY)
+    except Exception as e:
+        print(f"Error initializing Mistral client: {e}")
+        return []
+
+    embeddings = []
+
+    for i in range(0, len(input_texts), batch_size):
+        batch = input_texts[i:i + batch_size]
+        while True:
+            try:
+                embeddings_batch_response = client.embeddings.create(
+                    model="mistral-embed",
+                    inputs=batch
+                )
                 time.sleep(1)
-            else:
-                raise
+                embeddings.extend([data.embedding for data in embeddings_batch_response.data])
+                break
+            except Exception as e:
+                if "rate limit exceeded" in str(e).lower():
+                    print("Rate limit exceeded. Retrying after 10 seconds...")
+                    time.sleep(10)
+                else:
+                    print(f"Error in embedding batch: {e}")
+                    raise
+
+    return embeddings
 
 
-def vectorize(markdown_content, chunk_size=2048):
+def chunk_content(markdown_content, chunk_size=2048):
     """
     Vectorizes the given markdown content into chunks of specified size without cutting sentences.
     """
@@ -58,83 +71,98 @@ def vectorize(markdown_content, chunk_size=2048):
         chunks.append(markdown_content[start:end].strip())
         start = end
 
-    text_embeddings = get_text_embeddings(chunks)
-    return np.array(text_embeddings), chunks
-
-
-def load_in_vector_db(text_embeddings, chunks, metadatas=None, collection_name=COLLECTION_NAME):
-    """
-    Load the text embeddings into a ChromaDB collection for efficient similarity search.
-    """
-    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
-
-    if collection_name not in [col.name for col in client.list_collections()]:
-        collection = client.create_collection(collection_name)
-    else:
-        collection = client.get_collection(collection_name)
+    return chunks
 
-    existing_items = collection.get()
-    existing_ids = set()
 
-    for item in existing_items:
-        if isinstance(item, dict) and 'ids' in item:
-            existing_ids.update(item['ids'])
-
-    for embedding, chunk in zip(text_embeddings, chunks):
-        chunk_id = str(hash(chunk))
-        if chunk_id not in existing_ids:
-            collection.add(
-                embeddings=[embedding],
-                documents=[chunk],
-                metadatas=[metadatas],
-                ids=[chunk_id]
-            )
-            existing_ids.add(chunk_id)
+def generate_chunk_id(chunk):
+    """Generate a unique ID for a chunk using SHA-256 hash."""
+    return hashlib.sha256(chunk.encode('utf-8')).hexdigest()
 
 
-def see_database(collection_name=COLLECTION_NAME):
+def load_in_vector_db(markdown_content, metadatas=None, collection_name=COLLECTION_NAME):
     """
-    Load the ChromaDB collection and text chunks.
+    Load the text embeddings into a ChromaDB collection for efficient similarity search.
     """
-    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
-
-    if collection_name not in [col.name for col in client.list_collections()]:
-        print("Collection not found. Please ensure it is created.")
+    try:
+        client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+    except Exception as e:
+        print(f"Error initializing ChromaDB client: {e}")
         return
 
-    collection = client.get_collection(collection_name)
+    try:
+        if collection_name not in [col.name for col in client.list_collections()]:
+            collection = client.create_collection(collection_name)
+        else:
+            collection = client.get_collection(collection_name)
+    except Exception as e:
+        print(f"Error accessing collection: {e}")
+        return
 
-    items = collection.get()
+    try:
+        existing_items = collection.get()
+    except Exception as e:
+        print(f"Error retrieving existing items: {e}")
+        return
 
-    print(f"Type of items: {type(items)}")
-    print(f"Items: {items}")
+    existing_ids = set()
 
-    for item in items:
-        print(f"Type of item: {type(item)}")
-        print(f"Item: {item}")
+    if 'ids' in existing_items:
+        existing_ids.update(existing_items['ids'])
 
-        if isinstance(item, dict):
-            print(f"ID: {item.get('ids')}")
-            print(f"Document: {item.get('document')}")
-            print(f"Metadata: {item.get('metadata')}")
-        else:
-            print("Item is not a dictionary")
+    chunks = chunk_content(markdown_content)
+    text_to_vectorize = []
 
-        print("---")
+    for chunk in chunks:
+        chunk_id = generate_chunk_id(chunk)
+        if chunk_id not in existing_ids:
+            text_to_vectorize.append(chunk)
+
+    print(f"New chunks to vectorize: {len(text_to_vectorize)}")
+
+    if text_to_vectorize:
+        embeddings = vectorize(text_to_vectorize)
+        for embedding, chunk in zip(embeddings, text_to_vectorize):
+            chunk_id = generate_chunk_id(chunk)
+            if chunk_id not in existing_ids:
+                try:
+                    collection.add(
+                        embeddings=[embedding],
+                        documents=[chunk],
+                        metadatas=[metadatas],
+                        ids=[chunk_id]
+                    )
+                    existing_ids.add(chunk_id)
+                except Exception as e:
+                    print(f"Error adding embedding to collection: {e}")
 
 
 def retrieve_from_database(query, collection_name=COLLECTION_NAME, n_results=5, distance_threshold=None):
     """
     Retrieve the most similar documents from the vector store based on the query.
     """
-    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
-    collection = client.get_collection(collection_name)
-    query_embeddings = get_text_embeddings([query])
-    raw_results = collection.query(
-        query_embeddings=query_embeddings,
-        n_results=n_results,
-        include=["documents", "metadatas", "distances"]
-    )
+    try:
+        client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+        collection = client.get_collection(collection_name)
+    except Exception as e:
+        print(f"Error accessing collection: {e}")
+        return
+
+    try:
+        query_embeddings = vectorize([query])
+    except Exception as e:
+        print(f"Error vectorizing query: {e}")
+        return
+
+    try:
+        raw_results = collection.query(
+            query_embeddings=query_embeddings,
+            n_results=n_results,
+            include=["documents", "metadatas", "distances"]
+        )
+    except Exception as e:
+        print(f"Error querying collection: {e}")
+        return
+
     if distance_threshold is not None:
         filtered_results = {
             "ids": [],
@@ -155,4 +183,4 @@ def retrieve_from_database(query, collection_name=COLLECTION_NAME, n_results=5,
         else:
             return results
     else:
-        return raw_results
+        return raw_results

src/workflow.py

@@ -36,7 +36,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
 
-    #chosen_task_id = "7bd855d8-463d-4ed5-93ca-5fe35145f733"
+    #chosen_task_id = "8e867cd7-cff9-4e6c-867a-ff5ddc2550be"
     #questions_data = [item for item in questions_data if item.get("task_id") == chosen_task_id]
 
     for item in questions_data:

tools.json

@@ -48,18 +48,22 @@
     {
         "type": "function",
         "function": {
-            "name": "load_file",
-            "description": "Loads data from a file based on its extension.",
+            "name": "retrieve_knowledge",
+            "description": "Retrieves knowledge from a database with a provided query.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "file_path": {
+                    "query": {
                         "type": "string",
-                        "description": "The path to the file to be loaded."
+                        "description": "The query to search for in the vector store."
+                    },
+                    "n_results": {
+                        "type": "integer",
+                        "description": "The number of results to return. Default is 1."
                     }
                 },
                 "required": [
-                    "file_path"
+                    "query"
                 ]
             }
         }
@@ -102,30 +106,6 @@
             }
         }
     },
-    {
-        "type": "function",
-        "function": {
-            "name": "analyze_document",
-            "description": "Extracts specific information from a local PDF or local text document based on given keywords.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "file_path": {
-                        "type": "string",
-                        "description": "The path to the PDF or text document to analyze."
-                    },
-                    "keywords": {
-                        "type": "array",
-                        "description": "A list of keywords to search for in the document."
-                    }
-                },
-                "required": [
-                    "file_path",
-                    "keywords"
-                ]
-            }
-        }
-    },
     {
         "type": "function",
         "function": {
@@ -172,20 +152,18 @@
         "type": "function",
         "function": {
             "name": "execute_code",
-            "description": "Executes Python code from a file or a string and returns the final result.",
+            "description": "Executes Python code from a file and returns the final result.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "file_path": {
                         "type": "string",
                         "description": "The path to the file containing the Python code to execute."
-                    },
-                    "code_string": {
-                        "type": "string",
-                        "description": "The Python code as a string to execute."
                     }
                 },
-                "required": []
+                "required": [
+                    "file_path"
+                ]
             }
         }
     },
@@ -253,32 +231,5 @@
                 ]
             }
         }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "retrieve_knowledge",
-            "description": "Retrieves knowledge from a database with a provided query.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {
-                        "type": "string",
-                        "description": "The query to search for in the vector store."
-                    },
-                    "n_results": {
-                        "type": "integer",
-                        "description": "The number of results to return. Default is 1."
-                    },
-                    "distance_threshold": {
-                        "type": "number",
-                        "description": "The minimum distance score for results. Default is 0.5."
-                    }
-                },
-                "required": [
-                    "query"
-                ]
-            }
-        }
     }
 ]