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

{flock_core-0.3.14 → flock_core-0.3.15}/.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.15}/.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.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.14
+Version: 0.3.15
 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.15}/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.14/examples/03_misc → flock_core-0.3.15/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.15/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.15/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.15/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.15/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.15}/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.15}/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.15}/pyproject.toml

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

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

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

{flock_core-0.3.14 → flock_core-0.3.15}/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"\[([^\]]+)\]\(([^)]+)\)")

{flock_core-0.3.14 → flock_core-0.3.15}/src/flock/modules/callback/callback_module.py

@@ -70,17 +70,3 @@ class CallbackModule(FlockModule):
         """Run error callback if configured."""
         if self.config.on_error_callback:
             await self.config.on_error_callback(agent, error, inputs)
-
-    # Other hooks just pass through
-    async def post_initialize(self, agent: Any, inputs: dict[str, Any]) -> None:
-        pass
-
-    async def post_evaluate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> dict[str, Any]:
-        return result
-
-    async def post_terminate(
-        self, agent: Any, inputs: dict[str, Any], result: dict[str, Any]
-    ) -> None:
-        pass

{flock_core-0.3.14 → flock_core-0.3.15}/src/flock/modules/memory/memory_module.py

@@ -98,38 +98,14 @@ class MemoryModule(FlockModule):
         if not self.memory_store:
             return inputs
 
-        try:
-            input_text = json.dumps(inputs)
-            query_embedding = self.memory_store.compute_embedding(input_text)
-            concepts = await self._extract_concepts(
-                agent, input_text, self.config.number_of_concepts_to_extract
-            )
-
-            memory_results = []
-            for op in self.memory_ops:
-                if op["type"] == "semantic":
-                    semantic_results = self.memory_store.retrieve(
-                        query_embedding,
-                        concepts,
-                        similarity_threshold=self.config.similarity_threshold,
-                    )
-                    memory_results.extend(semantic_results)
-                elif op["type"] == "exact":
-                    exact_results = self.memory_store.exact_match(inputs)
-                    memory_results.extend(exact_results)
-
-            if memory_results:
-                logger.debug(
-                    f"Found {len(memory_results)} relevant memories",
-                    agent=agent.name,
-                )
-                inputs["memory_results"] = memory_results
+        inputs = await self.search_memory(agent, inputs)
 
-            return inputs
+        if "context" in inputs:
+            agent.input = (
+                agent.input + ", context: list | context with more information"
+            )
 
-        except Exception as e:
-            logger.warning(f"Memory retrieval failed: {e}", agent=agent.name)
-            return inputs
+        return inputs
 
     def get_memory_filename(self, module_name: str) -> str:
         """Generate the full file path for the memory file."""
@@ -205,12 +181,18 @@ class MemoryModule(FlockModule):
                     exact_results = self.memory_store.exact_match(query)
                     memory_results.extend(exact_results)
 
+            context: list[dict[str, Any]] = []
             if memory_results:
+                for result in memory_results:
+                    context.append(
+                        {"content": result.content, "concepts": result.concepts}
+                    )
+
                 logger.debug(
                     f"Found {len(memory_results)} relevant memories",
                     agent=agent.name,
                 )
-                query["memory_results"] = memory_results
+                query["context"] = context
 
             return query
 

{flock_core-0.3.14 → flock_core-0.3.15}/uv.lock

@@ -1119,7 +1119,7 @@ wheels = [
 
 [[package]]
 name = "flock-core"
-version = "0.3.14"
+version = "0.3.15"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },

flock_core-0.3.14/examples/README.md

@@ -1,24 +0,0 @@
-# Flock examples
-
-This part of the repository tries to explain how to use Flock to.
-
-## 01 Introduction
-
-Basic usage of flock
-
-## 02 Cook Book
-
-Recipes to let Flock cook or cook with Flock!
-
-## 03 Misc
-
-Additional Topics like modules and evaluators
-
-## 04 Fake It Til You Make It
-
-We re-implement examples of other agent framework.
-For the migrating birds.
-
-## notebooks
-
-Examples as jupyter notebooks