flock-core 0.3.14__tar.gz → 0.3.16__tar.gz

{flock_core-0.3.14 → flock_core-0.3.16}/.env_template

@@ -25,4 +25,4 @@ GITHUB_REPO=
 GITHUB_USERNAME=
 
 TAVILY_API_KEY=tvly-...
-SERPER_API_KEY=
+BING_SEARCH_V7_SUBSCRIPTION_KEY=

{flock_core-0.3.14 → flock_core-0.3.16}/.gitignore

@@ -31,6 +31,7 @@ metrics/
 concept_memory/
 news/
 .chroma/
+hierarchical_memory/
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

{flock_core-0.3.14 → flock_core-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.14
+Version: 0.3.16
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.3.14 → flock_core-0.3.16}/examples/01_introduction/06_simple_hand_off.py

@@ -26,12 +26,8 @@ project_plan_agent = FlockFactory.create_default_agent(
 # Default router = handoff to specific agent
 #idea_agent.handoff_router = DefaultRouter(config=DefaultRouterConfig(hand_off=project_plan_agent.name))
 
-# Agent router = handoff to agent based on agent's output
-idea_agent.handoff_router = AgentRouter(config=AgentRouterConfig(with_output=True))
-
 # LLM router = handoff to agent based on LLM's decision
-#idea_agent.handoff_router = LLMRouter(config=LLMRouterConfig())
-
+idea_agent.handoff_router = LLMRouter(config=LLMRouterConfig(with_output=True))
 
 flock.run(
     input={"query": "fun software project idea about ducks"},

flock_core-0.3.16/examples/02_concepts/context/context.py

@@ -0,0 +1,57 @@
+
+from flock.core import Flock, FlockFactory
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.routers.default.default_router import DefaultRouter, DefaultRouterConfig
+
+class ContextModule(FlockModule):
+    def terminate(self, agent, inputs, result, context=None):
+        context.set_variable("flock_agent1.a_random_name", "John Doe")
+     
+
+flock = Flock()
+
+
+
+# Flock has an advanced context system that allows you to store and retrieve data
+# across agents. The context is a dictionary that can be accessed and modified by 
+# all agents in the flock via modules
+# Agents will write their inputs and outputs to the context prefixed with "agentname."
+
+
+
+flock_agent_1 = FlockFactory.create_default_agent(
+    name="flock_agent1",
+    input="",
+    output="a_random_name: str",
+)
+
+
+flock_agent_2 = FlockFactory.create_default_agent(
+    name="flock_agent2",
+    input="a_random_name",
+    output="name_in_caps: str",
+)
+flock_agent_2.add_module(ContextModule(name="context_module", config= FlockModuleConfig()))
+
+# Agent3 will reverse John Doe to eoD nhoJ
+flock_agent_3 = FlockFactory.create_default_agent(
+    name="flock_agent3",
+    input="flock_agent1.a_random_name",
+    output="name_reversed: str",
+    wait_for_input=True,
+    print_context=True,
+)
+
+
+flock_agent_1.handoff_router = DefaultRouter(config=DefaultRouterConfig(hand_off=flock_agent_2.name))
+flock_agent_2.handoff_router = DefaultRouter(config=DefaultRouterConfig(hand_off=flock_agent_3.name))
+flock_agent_3.handoff_router = DefaultRouter(config=DefaultRouterConfig(hand_off=flock_agent_1.name))
+flock.add_agent(flock_agent_1)
+flock.add_agent(flock_agent_2)
+flock.add_agent(flock_agent_3)
+
+flock.run(
+    input={},
+    start_agent=flock_agent_1,
+    agents=[flock_agent_1, flock_agent_2, flock_agent_3]
+)

{flock_core-0.3.14/examples/03_misc → flock_core-0.3.16/examples/02_concepts}/evaluator/multi_hops_memory.py

@@ -48,10 +48,11 @@ def read_from_kg():
 def read_from_kg_and_evaluate():
   read_from_kg_and_evaluate_agent = FlockFactory.create_default_agent(model="openai/gpt-4o",name="read_from_kg_and_evaluate_agent", 
                                             input="query", 
-                                            output="short_answer",
-                                            output_theme=OutputTheme.aardvark_blue)
+                                            output="answer",
+                                            output_theme=OutputTheme.aardvark_blue,
+                                            enable_rich_tables=True)
   
-  read_from_kg_and_evaluate_agent.add_module(MemoryModule(name="mem_eval", config=MemoryModuleConfig(splitting_mode="characters")))
+  read_from_kg_and_evaluate_agent.add_module(MemoryModule(name="mem_eval", config=MemoryModuleConfig(splitting_mode="characters", enable_read_only_mode=True)))
 
 
 
@@ -69,8 +70,8 @@ def read_from_kg_and_evaluate():
 
 
 if __name__ == "__main__":
-  write_to_kg()
- #read_from_kg()
+  #write_to_kg()
+  read_from_kg()
   #read_from_kg_and_evaluate()
   pass
 

{flock_core-0.3.14/examples/03_misc → flock_core-0.3.16/examples/02_concepts}/modules/use_modules.py

@@ -52,10 +52,12 @@ agent = FlockFactory.create_default_agent(
 # Currently there are two graph based modules: Zep and Memory.
 # Memory is more lightweight and easier to use, but Zep offers more features and is more powerful.
 
-# zep = ZepModule(name="zep",config=ZepModuleConfig())
-zep = MemoryModule(name="mem_split",config=MemoryModuleConfig(splitting_mode="characters"))
+zep = ZepModule(name="zep",config=ZepModuleConfig())
 agent.add_module(zep)
 
+mem = MemoryModule(name="mem_split",config=MemoryModuleConfig(splitting_mode="characters", number_of_concepts_to_extract=5))
+agent.add_module(mem)
+
 
 flock.add_agent(agent)
 result = flock.run(

{flock_core-0.3.14/examples/playground → flock_core-0.3.16/examples/03_apps}/roguelike/game.py

@@ -13,6 +13,7 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 from rich.prompt import Prompt
+from pydantic import BaseModel
 
 # Basic game constants
 MAP_WIDTH = 20
@@ -49,6 +50,16 @@ class Action(Enum):
     ATTACK = auto()
     TALK = auto()
     WAIT = auto()
+    
+
+
+    
+class Map(BaseModel):
+    width: int
+    height: int
+    data: List[str]
+    
+
 
 @dataclass
 class Entity:
@@ -72,6 +83,14 @@ def format_entity(entity: Entity) -> str:
     """Helper to wrap an entity's name in rich markup based on its color."""
     return f"[{entity.color}]{entity.name}[/{entity.color}]"
 
+class Scene(BaseModel):
+    name: str
+    description: str
+    entities: List[Entity]
+    map_data: Map
+    turn: int
+    player_index: int
+
 @dataclass
 class GameState:
     map_data: List[str]
@@ -167,8 +186,7 @@ class RoguelikeGame:
                         reasoning: str | Short explanation of why this action was chosen
                     """,
                     temperature=0.7,
-                    enable_rich_tables=True,
-                    output_theme=OutputTheme.dracula
+                    no_output=True
                 )
                 self.flock.add_agent(agent)
                 entity.agent_name = agent.name
@@ -319,7 +337,7 @@ class RoguelikeGame:
             target_name = result.get("target", "")
             message = result.get("message", "")
             reasoning = result.get("reasoning", "")
-            self.state.add_to_log(f"{format_entity(entity)} thinks: {reasoning}")
+            #self.state.add_to_log(f"{format_entity(entity)} thinks: {reasoning}")
 
             target = None
             if target_name:

{flock_core-0.3.14/examples/notebooks_wip → flock_core-0.3.16/examples/04_comparison}/rag_comparison/rag.ipynb

@@ -152,7 +152,7 @@
     "chroma_client = chromadb.PersistentClient(path=\".chroma\")\n",
     "collection = chroma_client.get_or_create_collection(name=\"my_cnn_news\")        \n",
     "\n",
-    "query = \"What recent actions have been taken by the Trump administration regarding the federal workforce, and how does this relate to the broader context of Trump's policies and proposals?\"\n",
+    "query=\"What is the vaccination rate goal set by HHS to help prevent outbreaks of measles?\"\n",
     "results = collection.query(query_texts=[query], n_results=3)\n",
     "debug(results)\n",
     "\n"
@@ -242,16 +242,22 @@
    "outputs": [],
    "source": [
     "\n",
+    "news_files = glob.glob(\"news/*.md\")\n",
+    "news_files = [open(file, \"r\", encoding=\"utf-8\") for file in news_files]\n",
+    "news_files = [(file.read(),file.name) for file in news_files]\n",
     "\n",
-    "\n",
-    "write_to_kg_agent = FlockFactory.create_default_agent(model=\"openai/gpt-4o\",name=\"write_to_kg_agent\", \n",
+    "write_to_kg_agent = FlockFactory.create_default_agent(model=\"openai/gpt-4o\",name=\"news_to_kg_agent\", \n",
     "                                            input=\"data\", \n",
-    "                                            output_theme=OutputTheme.aardvark_blue)\n",
+    "                                            output_theme=OutputTheme.aardvark_blue, shorten_long_lists=True)\n",
+    "\n",
     "\n",
+    "write_to_kg_agent.evaluator = MemoryEvaluator(name=\"news_to_kg_agent\", \n",
+    "                                              config=MemoryEvaluatorConfig(splitting_mode=\"characters\", \n",
+    "                                                                           number_of_concepts_to_extract=3))\n",
     "\n",
-    "write_to_kg_agent.evaluator = MemoryEvaluator(name=\"mem_eval\", \n",
-    "                                              config=MemoryEvaluatorConfig(splitting_mode=\"none\", \n",
-    "                                                                           number_of_concepts_to_extract=5))\n",
+    "for file_content, file_name in news_files:\n",
+    "    result = write_to_kg_agent.run(inputs={\"data\": file_content})\n",
+    "    print(result)\n",
     "\n",
     "\n",
     "\n",

flock_core-0.3.16/examples/README.md

@@ -0,0 +1,27 @@
+# Flock examples
+
+This part of the repository tries to explain how to use Flock to.
+
+## 01 Introduction
+
+Basic usage of flock
+
+## 02 Concepts
+
+Recipes and samples to some of flock's concepts
+
+## 03 Apps
+
+Full apps powered by flock
+
+## 04 Comparison
+
+We are comparing flock to other frameworks
+
+## 05 Documentation
+
+Code Snippets out of the documentation
+
+## playground
+
+André's Playground - stay away!

{flock_core-0.3.14 → flock_core-0.3.16}/examples/playground/hier/her_vis.py

@@ -6,7 +6,9 @@ import numpy as np
 from matplotlib.colors import LinearSegmentedColormap
 from typing import Dict, List, Set, Tuple
 
-from hierarchical_memory_implementation import ConceptRelationType, HierarchicalMemoryGraph
+from flock.modules.hierarchical.memory import ConceptRelationType, HierarchicalMemoryGraph
+
+
 
 
 class MemoryVisualizer:

{flock_core-0.3.14 → flock_core-0.3.16}/examples/playground/hier/hier_mem.py

@@ -4,18 +4,27 @@ import asyncio
 from typing import Dict, Any
 
 from flock.core import FlockFactory
-from flock.core.output_themes import OutputTheme
+from flock.core.logging.formatters.themes import OutputTheme
+from flock.evaluators.memory.hierarchical_evaluator import HierarchicalMemoryEvaluator, HierarchicalMemoryEvaluatorConfig
+from flock.modules.hierarchical.memory import ConceptRelationType, HierarchicalMemoryModuleConfig
+from flock.modules.hierarchical.module import HierarchicalMemoryModule
 
-# Import the new hierarchical memory components
-from hierarchical_memory_implementation import ConceptRelationType, MemoryModuleConfig
-from hierarchical_memory_module import HierarchicalMemoryModule
 
 
 async def main():
     """Demonstrate the hierarchical memory capabilities."""
     
     # Create an agent with hierarchical memory
-    memory_config = MemoryModuleConfig(
+    memory_config = HierarchicalMemoryEvaluatorConfig(
+        folder_path="hierarchical_memory/",
+        enable_hierarchical_concepts=True,
+        upward_propagation_factor=0.8,
+        downward_propagation_factor=0.6,
+        similarity_threshold=0.5,
+        splitting_mode="semantic",
+        save_after_update=True,
+    )
+    memory_module_config = HierarchicalMemoryModuleConfig(
         folder_path="hierarchical_memory/",
         enable_hierarchical_concepts=True,
         upward_propagation_factor=0.8,
@@ -23,9 +32,9 @@ async def main():
         similarity_threshold=0.5,
         splitting_mode="semantic"
     )
-    
     # Create the memory module with the configuration
-    memory_module = HierarchicalMemoryModule(name="hierarchical_memory", config=memory_config)
+    memory_eval = HierarchicalMemoryEvaluator(name="hierarchical_memory", config=memory_config)
+    memory_module = HierarchicalMemoryModule(name="hierarchical_memory", config=memory_module_config)
     
     # Create the agent with the memory module
     agent = FlockFactory.create_default_agent(
@@ -36,29 +45,30 @@ async def main():
     )
     
     # Replace the default evaluator with our hierarchical memory module
-    agent.evaluator = memory_module
+    agent.evaluator = memory_eval
     
-    # Initialize the agent
-    await memory_module.initialize(agent, {})
+
     
     # Add some initial data with implicit hierarchies
     print("Adding initial information...")
-    await agent.run(inputs={"data": "Andre is 38 years old and author of the agent framework 'flock'"})
-    await agent.run(inputs={"data": "Andre works for White Duck"})
-    await agent.run(inputs={"data": "Andre has two cats"})
-    await agent.run(inputs={"data": "White Duck is a cloud consulting company"})
-    await agent.run(inputs={"data": "Flock is an agent framework designed for scalable multi-agent systems"})
+    await agent.run_async(inputs={"data": "Andre is 38 years old and author of the agent framework 'flock'"})
+    await agent.run_async(inputs={"data": "Andre works for White Duck"})
+    await agent.run_async(inputs={"data": "Andre has two cats"})
+    await agent.run_async(inputs={"data": "White Duck is a cloud consulting company"})
+    await agent.run_async(inputs={"data": "Flock is an agent framework designed for scalable multi-agent systems"})
     
     # Add data about Andre's cats with names
-    await agent.run(inputs={"data": "One of Andre's cats is named Luna"})
-    await agent.run(inputs={"data": "The other cat is named Lucy"})
+    await agent.run_async(inputs={"data": "One of Andre's cats is named Luna"})
+    await agent.run_async(inputs={"data": "The other cat is named Lucy"})
     
     # Add location information
-    await agent.run(inputs={"data": "Andre lives in Germany"})
-    await agent.run(inputs={"data": "Germany is in Europe"})
+    await agent.run_async(inputs={"data": "Andre lives in Germany"})
+    await agent.run_async(inputs={"data": "Germany is in Europe"})
     
     # Add explicit hierarchical relationships
     print("\nAdding explicit hierarchical relationships...")
+    
+    
     await memory_module.add_hierarchical_relationship(
         agent=agent,
         child_concept="cat",

{flock_core-0.3.14 → flock_core-0.3.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.3.14"
+version = "0.3.16"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.3.14 → flock_core-0.3.16}/src/flock/core/context/context.py

@@ -1,9 +1,10 @@
 import uuid
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict
 from datetime import datetime
 from typing import Any, Literal
 
 from opentelemetry import trace
+from pydantic import BaseModel, Field
 
 from flock.core.context.context_vars import FLOCK_LAST_AGENT, FLOCK_LAST_RESULT
 from flock.core.logging.logging import get_logger
@@ -13,34 +14,31 @@ logger = get_logger("context")
 tracer = trace.get_tracer(__name__)
 
 
-@dataclass
-class AgentRunRecord:
-    id: str = field(default="")
-    agent: str = field(default="")
-    data: dict[str, Any] = field(default_factory=dict)
-    timestamp: str = field(default="")
-    hand_off: dict = field(default_factory=dict)
-    called_from: str = field(default="")
+class AgentRunRecord(BaseModel):
+    id: str = Field(default="")
+    agent: str = Field(default="")
+    data: dict[str, Any] = Field(default_factory=dict)
+    timestamp: str = Field(default="")
+    hand_off: dict | None = Field(default_factory=dict)
+    called_from: str = Field(default="")
 
 
-@dataclass
-class AgentDefinition:
-    agent_type: str = field(default="")
-    agent_name: str = field(default="")
-    agent_data: dict = field(default_factory=dict)
-    serializer: Literal["json", "cloudpickle", "msgpack"] = field(
+class AgentDefinition(BaseModel):
+    agent_type: str = Field(default="")
+    agent_name: str = Field(default="")
+    agent_data: dict = Field(default_factory=dict)
+    serializer: Literal["json", "cloudpickle", "msgpack"] = Field(
         default="cloudpickle"
     )
 
 
-@dataclass
-class FlockContext(Serializable):
-    state: dict[str, Any] = field(default_factory=dict)
-    history: list[AgentRunRecord] = field(default_factory=list)
-    agent_definitions: dict[str, AgentDefinition] = field(default_factory=dict)
-    run_id: str = field(default="")
-    workflow_id: str = field(default="")
-    workflow_timestamp: str = field(default="")
+class FlockContext(Serializable, BaseModel):
+    state: dict[str, Any] = Field(default_factory=dict)
+    history: list[AgentRunRecord] = Field(default_factory=list)
+    agent_definitions: dict[str, AgentDefinition] = Field(default_factory=dict)
+    run_id: str = Field(default="")
+    workflow_id: str = Field(default="")
+    workflow_timestamp: str = Field(default="")
 
     def record(
         self,

{flock_core-0.3.14 → flock_core-0.3.16}/src/flock/core/flock_agent.py

@@ -11,6 +11,7 @@ import cloudpickle
 from opentelemetry import trace
 from pydantic import BaseModel, Field
 
+from flock.core.context.context import FlockContext
 from flock.core.flock_evaluator import FlockEvaluator
 from flock.core.flock_module import FlockModule
 from flock.core.flock_router import FlockRouter
@@ -73,6 +74,11 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         description="FlockModules attached to this agent",
     )
 
+    context: FlockContext | None = Field(
+        default=None,
+        description="Context associated with flock",
+    )
+
     def add_module(self, module: FlockModule) -> None:
         """Add a module to this agent."""
         self.modules[module.name] = module
@@ -95,6 +101,13 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
         with tracer.start_as_current_span("agent.initialize") as span:
             span.set_attribute("agent.name", self.name)
             span.set_attribute("inputs", str(inputs))
+            if not self.context:
+                self.context = FlockContext()
+
+            if self.name not in self.context.agent_definitions:
+                self.context.add_agent_definition(
+                    type(self), self.name, self.to_dict()
+                )
 
             try:
                 for module in self.get_enabled_modules():
@@ -102,7 +115,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
                         f"agent.initialize - module {module.name}",
                         agent=self.name,
                     )
-                    await module.initialize(self, inputs)
+                    await module.initialize(self, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during initialize",
@@ -124,7 +137,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             )
             try:
                 for module in self.get_enabled_modules():
-                    await module.terminate(self, inputs, inputs)
+                    await module.terminate(self, inputs, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during terminate",
@@ -139,7 +152,7 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
             try:
                 for module in self.get_enabled_modules():
-                    await module.on_error(self, error, inputs)
+                    await module.on_error(self, error, inputs, self.context)
             except Exception as module_error:
                 logger.error(
                     "Error during on_error",
@@ -154,13 +167,15 @@ class FlockAgent(BaseModel, ABC, DSPyIntegrationMixin):
             span.set_attribute("inputs", str(inputs))
 
             for module in self.get_enabled_modules():
-                inputs = await module.pre_evaluate(self, inputs)
+                inputs = await module.pre_evaluate(self, inputs, self.context)
 
             try:
                 result = await self.evaluator.evaluate(self, inputs, self.tools)
 
                 for module in self.get_enabled_modules():
-                    result = await module.post_evaluate(self, inputs, result)
+                    result = await module.post_evaluate(
+                        self, inputs, result, self.context
+                    )
 
                 span.set_attribute("result", str(result))
 

{flock_core-0.3.14 → flock_core-0.3.16}/src/flock/core/flock_factory.py

@@ -34,6 +34,8 @@ class FlockFactory:
         temperature: float = 0.0,
         max_tokens: int = 4096,
         alert_latency_threshold_ms: int = 30000,
+        no_output: bool = False,
+        print_context: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -63,6 +65,8 @@ class FlockFactory:
             render_table=enable_rich_tables,
             theme=output_theme,
             wait_for_input=wait_for_input,
+            no_output=no_output,
+            print_context=print_context,
         )
         output_module = OutputModule("output", config=output_config)
 

{flock_core-0.3.14 → flock_core-0.3.16}/src/flock/core/flock_module.py

@@ -5,6 +5,8 @@ from typing import Any, TypeVar
 
 from pydantic import BaseModel, Field, create_model
 
+from flock.core.context.context import FlockContext
+
 T = TypeVar("T", bound="FlockModuleConfig")
 
 
@@ -50,30 +52,50 @@ class FlockModule(BaseModel, ABC):
         default_factory=FlockModuleConfig, description="Module configuration"
     )
 
-    async def initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
+    async def initialize(
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> None:
         """Called when the agent starts running."""
         pass
 
     async def pre_evaluate(
-        self, agent: Any, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called before agent evaluation, can modify inputs."""
         return inputs
 
     async def post_evaluate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> dict[str, Any]:
         """Called after agent evaluation, can modify results."""
         return result
 
     async def terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
+        self,
+        agent: Any,
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when the agent finishes running."""
         pass
 
     async def on_error(
-        self, agent: Any, error: Exception, inputs: dict[str, Any]
+        self,
+        agent: Any,
+        error: Exception,
+        inputs: dict[str, Any],
+        context: FlockContext | None = None,
     ) -> None:
         """Called when an error occurs during agent execution."""
         pass

{flock_core-0.3.14 → flock_core-0.3.16}/src/flock/core/tools/basic_tools.py

@@ -43,6 +43,30 @@ def web_search_duckduckgo(
         raise
 
 
+@traced_and_logged
+def web_search_bing(keywords: str):
+    try:
+        import httpx
+
+        subscription_key = os.environ["BING_SEARCH_V7_SUBSCRIPTION_KEY"]
+        endpoint = "https://api.bing.microsoft.com/v7.0/search"
+
+        # Query term(s) to search for.
+        query = keywords
+
+        # Construct a request
+        mkt = "en-US"
+        params = {"q": query, "mkt": mkt}
+        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
+
+        response = httpx.get(endpoint, headers=headers, params=params)
+        response.raise_for_status()
+        search_results = response.json()
+        return search_results["webPages"]
+    except Exception:
+        raise
+
+
 def extract_links_from_markdown(markdown: str, url: str) -> list:
     # Regular expression to find all markdown links
     link_pattern = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")