Developed the basis

(cherry picked from commit 3b22ac66d7d7e18a6b29687a07e06ce49b5e8487)

src/model.py

@@ -0,0 +1,21 @@
+from smolagents import HfApiModel
+
+
+def get_model(
+        model_id: str, 
+        provider: str,
+        max_tokens: int = 2048,
+        **kwargs
+) -> HfApiModel:
+    return HfApiModel(
+        model_id=model_id,
+        provider=provider,
+        max_tokens=max_tokens,
+        **kwargs
+    )
+
+
+if __name__ == "__main__":
+    ModelId = "Qwen/Qwen2.5-Coder-32B-Instruct"
+    Provider = "together"
+    model = get_model(ModelId, Provider)

src/party_planner/rag_agent.py

@@ -0,0 +1,72 @@
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from smolagents import Tool
+from langchain_community.retrievers import BM25Retriever
+from smolagents import CodeAgent, HfApiModel
+
+class PartyPlanningRetrieverTool(Tool):
+    name = "party_planning_retriever"
+    description = "Uses semantic search to retrieve relevant party planning ideas for Alfred’s superhero-themed party at Wayne Manor."
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The query to perform. This should be a query related to party planning or superhero themes.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs, **kwargs):
+        super().__init__(**kwargs)
+        self.retriever = BM25Retriever.from_documents(
+            docs, k=5  # Retrieve the top 5 documents
+        )
+
+    def forward(self, query: str) -> str:
+        assert isinstance(query, str), "Your search query must be a string"
+
+        docs = self.retriever.invoke(
+            query,
+        )
+        return "\nRetrieved ideas:\n" + "".join(
+            [
+                f"\n\n===== Idea {str(i)} =====\n" + doc.page_content
+                for i, doc in enumerate(docs)
+            ]
+        )
+
+# Simulate a knowledge base about party planning
+party_ideas = [
+    {"text": "A superhero-themed masquerade ball with luxury decor, including gold accents and velvet curtains.", "source": "Party Ideas 1"},
+    {"text": "Hire a professional DJ who can play themed music for superheroes like Batman and Wonder Woman.", "source": "Entertainment Ideas"},
+    {"text": "For catering, serve dishes named after superheroes, like 'The Hulk's Green Smoothie' and 'Iron Man's Power Steak.'", "source": "Catering Ideas"},
+    {"text": "Decorate with iconic superhero logos and projections of Gotham and other superhero cities around the venue.", "source": "Decoration Ideas"},
+    {"text": "Interactive experiences with VR where guests can engage in superhero simulations or compete in themed games.", "source": "Entertainment Ideas"}
+]
+
+source_docs = [
+    Document(page_content=doc["text"], metadata={"source": doc["source"]})
+    for doc in party_ideas
+]
+
+# Split the documents into smaller chunks for more efficient search
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=500,
+    chunk_overlap=50,
+    add_start_index=True,
+    strip_whitespace=True,
+    separators=["\n\n", "\n", ".", " ", ""],
+)
+docs_processed = text_splitter.split_documents(source_docs)
+
+# Create the retriever tool
+party_planning_retriever = PartyPlanningRetrieverTool(docs_processed)
+
+# Initialize the agent
+agent = CodeAgent(tools=[party_planning_retriever], model=HfApiModel())
+
+# Example usage
+response = agent.run(
+    "Find ideas for a luxury superhero-themed party, including entertainment, catering, and decoration options."
+)
+
+print(response)

src/party_planner/rag_multiAgents.py

@@ -0,0 +1,74 @@
+from smolagents import GoogleSearchTool, VisitWebpageTool
+
+
+from src.agent import create_agent
+from src.model import get_model
+from src.party_planner.tools.travel_time import calculate_cargo_travel_time
+from src.party_planner.utils import check_reasoning_and_plot
+
+
+web_agent = create_agent(
+    "code_agent",
+    "web_agent",
+    model=get_model(
+        "Qwen/Qwen2.5-Coder-32B-Instruct",
+        provider="together",
+        max_tokens=1024
+    ),
+    tools=[
+        GoogleSearchTool(provider="serper"),
+        VisitWebpageTool(),
+        calculate_cargo_travel_time,
+    ],
+    description="Browses the web to find information",
+    verbosity=0,
+    max_steps=10
+)
+
+
+manager_agent = create_agent(
+    "code_agent",
+    "manager_agent",
+    get_model(
+    "deepseek-ai/DeepSeek-R1",
+        "together",
+        2048
+    ),
+[calculate_cargo_travel_time],
+    15,
+    [
+        "geopandas",
+        "plotly",
+        "shapely",
+        "json",
+        "pandas",
+        "numpy",
+    ],
+    interval=5,
+    verbosity=2,
+    final_answer_checks=[check_reasoning_and_plot],
+    managed_agents=[web_agent]
+)
+
+
+if __name__ == '__main__':
+    manager_agent.visualize()
+
+    manager_agent.run("""
+    Find all Batman filming locations in the world, calculate the time to transfer via cargo plane to here (we're in Gotham, 40.7128° N, 74.0060° W).
+    Also give me some supercar factories with the same cargo plane transfer time. You need at least 6 points in total.
+    Represent this as spatial map of the world, with the locations represented as scatter points with a color that depends on the travel time, and save it to saved_map.png!
+
+    Here's an example of how to plot and return a map:
+    import plotly.express as px
+    df = px.data.carshare()
+    fig = px.scatter_map(df, lat="centroid_lat", lon="centroid_lon", text="name", color="peak_hour", size=100,
+         color_continuous_scale=px.colors.sequential.Magma, size_max=15, zoom=1)
+    fig.show()
+    fig.write_image("saved_image.png")
+    final_answer(fig)
+
+    Never try to process strings using code: when you have a string to read, just print it and you'll see it.
+    """)
+
+    manager_agent.python_executor.state["fig"]

src/party_planner/tools/travel_time.py

@@ -0,0 +1,62 @@
+import math
+from typing import Optional, Tuple
+
+from smolagents import tool
+
+
+@tool
+def calculate_cargo_travel_time(
+    origin_coords: Tuple[float, float],
+    destination_coords: Tuple[float, float],
+    cruising_speed_kmh: Optional[float] = 750.0,  # Average speed for cargo planes
+) -> float:
+    """
+    Calculate the travel time for a cargo plane between two points on Earth using great-circle distance.
+
+    Args:
+        origin_coords: Tuple of (latitude, longitude) for the starting point
+        destination_coords: Tuple of (latitude, longitude) for the destination
+        cruising_speed_kmh: Optional cruising speed in km/h (defaults to 750 km/h for typical cargo planes)
+
+    Returns:
+        float: The estimated travel time in hours
+
+    Example:
+        >>> # Chicago (41.8781° N, 87.6298° W) to Sydney (33.8688° S, 151.2093° E)
+        >>> result = calculate_cargo_travel_time((41.8781, -87.6298), (-33.8688, 151.2093))
+    """
+
+    def to_radians(degrees: float) -> float:
+        return degrees * (math.pi / 180)
+
+    # Extract coordinates
+    lat1, lon1 = map(to_radians, origin_coords)
+    lat2, lon2 = map(to_radians, destination_coords)
+
+    # Earth's radius in kilometers
+    EARTH_RADIUS_KM = 6371.0
+
+    # Calculate great-circle distance using the haversine formula
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+
+    a = (
+        math.sin(dlat / 2) ** 2
+        + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
+    )
+    c = 2 * math.asin(math.sqrt(a))
+    distance = EARTH_RADIUS_KM * c
+
+    # Add 10% to account for non-direct routes and air traffic controls
+    actual_distance = distance * 1.1
+
+    # Calculate flight time
+    # Add 1 hour for takeoff and landing procedures
+    flight_time = (actual_distance / cruising_speed_kmh) + 1.0
+
+    # Format the results
+    return round(flight_time, 2)
+
+
+if __name__ == "__main__":
+    print(calculate_cargo_travel_time((41.8781, -87.6298), (-33.8688, 151.2093)))