refactor: remove unimported packages

agent.py

@@ -1,32 +1,15 @@
 import os
 from dotenv import load_dotenv
-from typing import List, Dict, Any, Optional
-import tempfile
-import re
-import json
-import requests
-from urllib.parse import urlparse
-import pytesseract
-from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
-import cmath
-import pandas as pd
-import uuid
-import numpy as np
 from tools.python_interpreter import CodeInterpreter
 
 interpreter_instance = CodeInterpreter()
-hf_token = os.environ["HUGGING_FACE_TOKEN"]
 
 
 from tools.image import *
 
 """Langraph"""
 from langgraph.graph import START, StateGraph, MessagesState
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader
-from langchain_community.document_loaders import ArxivLoader
 from langgraph.prebuilt import ToolNode, tools_condition
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_groq import ChatGroq
 from langchain_huggingface import (
     ChatHuggingFace,
@@ -35,13 +18,12 @@ from langchain_huggingface import (
 )
 from langchain_community.vectorstores import SupabaseVectorStore
 from langchain_core.messages import SystemMessage, HumanMessage
-from langchain_core.tools import tool
 from langchain.tools.retriever import create_retriever_tool
 from supabase.client import Client, create_client
 # ------- Tools
 from tools.browse import web_search, wiki_search, arxiv_search
 from tools.document_process import save_and_read_file, analyze_csv_file, analyze_excel_file, extract_text_from_image, download_file_from_url
-from tools.image_tools import analyze_image, generate_simple_image 
+from tools.image_tools import analyze_image, generate_simple_image , transform_image, draw_on_image, combine_images
 from tools.simple_math import multiply, add, subtract, divide, modulus, power, square_root
 from tools.python_interpreter import execute_code_lang
 
@@ -64,8 +46,8 @@ supabase: Client = create_client(
 vector_store = SupabaseVectorStore(
     client=supabase,
     embedding=embeddings,
-    table_name="documents2",
-    query_name="match_documents_2",
+    table_name="documents",
+    query_name="match_documents_langchain",
 )
 create_retriever_tool = create_retriever_tool(
     retriever=vector_store.as_retriever(),
@@ -92,13 +74,17 @@ tools = [
     analyze_excel_file,
     execute_code_lang,
     analyze_image,
+    transform_image,
+    draw_on_image,
     generate_simple_image,
+    combine_images,
 ]
 
 def build_graph(provider: str = "groq"):
     if provider == "groq":
         # Groq https://console.groq.com/docs/models
         llm = ChatGroq(model="qwen-qwq-32b", temperature=0)
+        # llm = ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0)
     elif provider == "huggingface":
         llm = ChatHuggingFace(
             llm=HuggingFaceEndpoint(
@@ -122,7 +108,9 @@ def build_graph(provider: str = "groq"):
 
     def retriever(state: MessagesState):
         """Retriever Node"""
-        similar_question = vector_store.similiarity_search(state['messages'])
+        # Extract the latest message content
+        query = state['messages'][-1].content
+        similar_question = vector_store.similarity_search(query, k = 2)
         if similar_question:  
             example_msg = HumanMessage(
                 content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
@@ -131,6 +119,7 @@ def build_graph(provider: str = "groq"):
         else:
             return {"messages": [sys_msg] + state["messages"]}
 
+
     builder = StateGraph(MessagesState)
     builder.add_node("retriever", retriever)
     builder.add_node("assistant", assistant)
@@ -142,7 +131,8 @@ def build_graph(provider: str = "groq"):
     return builder.compile()
 
 if __name__ == "__main__":
-    question = "When was the Cyrus Cylinder created?"
+    question = "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia."
+    # question = """Q is Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec. What does Teal'c say in response to the question "Isn't that hot?"""
     graph = build_graph(provider="groq")
     messages = [HumanMessage(content=question)]
     messages = graph.invoke({"messages": messages})

app.py

@@ -1,4 +1,5 @@
 import os
+import time
 import gradio as gr
 import requests
 import inspect
@@ -84,6 +85,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+        # time.sleep(10)
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})

tools/document_process.py

@@ -1,6 +1,6 @@
 from langchain_core.tools import tool
 import os
-from typing import List, Dict, Any, Optional
+from typing import Optional
 import tempfile
 import requests
 from urllib.parse import urlparse

tools/image_tools.py

@@ -1,7 +1,8 @@
 from langchain_core.tools import tool
 from tools.image import decode_image, encode_image, save_image
-from typing import Dict, Any, Optional
+from typing import Dict, Any, List, Optional
 import numpy as np
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
 
 @tool
 def analyze_image(image_base64: str) -> Dict[str, Any]:
@@ -44,6 +45,132 @@ def analyze_image(image_base64: str) -> Dict[str, Any]:
     except Exception as e:
         return {"error": str(e)}
 
+@tool
+def transform_image(
+    image_base64: str, operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Apply transformations: resize, rotate, crop, flip, brightness, contrast, blur, sharpen, grayscale.
+    Args:
+        image_base64 (str): Base64 encoded input image
+        operation (str): Transformation operation
+        params (Dict[str, Any], optional): Parameters for the operation
+    Returns:
+        Dictionary with transformed image (base64)
+    """
+    try:
+        img = decode_image(image_base64)
+        params = params or {}
+
+        if operation == "resize":
+            img = img.resize(
+                (
+                    params.get("width", img.width // 2),
+                    params.get("height", img.height // 2),
+                )
+            )
+        elif operation == "rotate":
+            img = img.rotate(params.get("angle", 90), expand=True)
+        elif operation == "crop":
+            img = img.crop(
+                (
+                    params.get("left", 0),
+                    params.get("top", 0),
+                    params.get("right", img.width),
+                    params.get("bottom", img.height),
+                )
+            )
+        elif operation == "flip":
+            if params.get("direction", "horizontal") == "horizontal":
+                img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                img = img.transpose(Image.FLIP_TOP_BOTTOM)
+        elif operation == "adjust_brightness":
+            img = ImageEnhance.Brightness(img).enhance(params.get("factor", 1.5))
+        elif operation == "adjust_contrast":
+            img = ImageEnhance.Contrast(img).enhance(params.get("factor", 1.5))
+        elif operation == "blur":
+            img = img.filter(ImageFilter.GaussianBlur(params.get("radius", 2)))
+        elif operation == "sharpen":
+            img = img.filter(ImageFilter.SHARPEN)
+        elif operation == "grayscale":
+            img = img.convert("L")
+        else:
+            return {"error": f"Unknown operation: {operation}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"transformed_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def draw_on_image(
+    image_base64: str, drawing_type: str, params: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Draw shapes (rectangle, circle, line) or text onto an image.
+    Args:
+        image_base64 (str): Base64 encoded input image
+        drawing_type (str): Drawing type
+        params (Dict[str, Any]): Drawing parameters
+    Returns:
+        Dictionary with result image (base64)
+    """
+    try:
+        img = decode_image(image_base64)
+        draw = ImageDraw.Draw(img)
+        color = params.get("color", "red")
+
+        if drawing_type == "rectangle":
+            draw.rectangle(
+                [params["left"], params["top"], params["right"], params["bottom"]],
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "circle":
+            x, y, r = params["x"], params["y"], params["radius"]
+            draw.ellipse(
+                (x - r, y - r, x + r, y + r),
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "line":
+            draw.line(
+                (
+                    params["start_x"],
+                    params["start_y"],
+                    params["end_x"],
+                    params["end_y"],
+                ),
+                fill=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "text":
+            font_size = params.get("font_size", 20)
+            try:
+                font = ImageFont.truetype("arial.ttf", font_size)
+            except IOError:
+                font = ImageFont.load_default()
+            draw.text(
+                (params["x"], params["y"]),
+                params.get("text", "Text"),
+                fill=color,
+                font=font,
+            )
+        else:
+            return {"error": f"Unknown drawing type: {drawing_type}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"result_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
 @tool
 def generate_simple_image(
     image_type: str,
@@ -109,3 +236,50 @@ def generate_simple_image(
 
     except Exception as e:
         return {"error": str(e)}
+
+
+@tool
+def combine_images(
+    images_base64: List[str], operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Combine multiple images (collage, stack, blend).
+    Args:
+        images_base64 (List[str]): List of base64 images
+        operation (str): Combination type
+        params (Dict[str, Any], optional)
+    Returns:
+        Dictionary with combined image (base64)
+    """
+    try:
+        images = [decode_image(b64) for b64 in images_base64]
+        params = params or {}
+
+        if operation == "stack":
+            direction = params.get("direction", "horizontal")
+            if direction == "horizontal":
+                total_width = sum(img.width for img in images)
+                max_height = max(img.height for img in images)
+                new_img = Image.new("RGB", (total_width, max_height))
+                x = 0
+                for img in images:
+                    new_img.paste(img, (x, 0))
+                    x += img.width
+            else:
+                max_width = max(img.width for img in images)
+                total_height = sum(img.height for img in images)
+                new_img = Image.new("RGB", (max_width, total_height))
+                y = 0
+                for img in images:
+                    new_img.paste(img, (0, y))
+                    y += img.height
+        else:
+            return {"error": f"Unsupported combination operation {operation}"}
+
+        result_path = save_image(new_img)
+        result_base64 = encode_image(result_path)
+        return {"combined_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+