flock-core 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

flock_core-0.1.1.dist-info/METADATA

@@ -1,449 +0,0 @@
-Metadata-Version: 2.4
-Name: flock-core
-Version: 0.1.1
-Summary: An agent framework for the age of agents
-Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
-License-File: LICENSE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Requires-Dist: cloudpickle>=3.1.1
-Requires-Dist: devtools>=0.12.2
-Requires-Dist: dspy>=2.5.42
-Requires-Dist: httpx>=0.28.1
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: marimo>=0.10.15
-Requires-Dist: markdownify>=0.14.1
-Requires-Dist: monsterui>=0.0.23
-Requires-Dist: msgpack>=1.1.0
-Requires-Dist: pydantic>=2.10.5
-Requires-Dist: python-box>=7.3.2
-Requires-Dist: python-fasthtml>=0.12.0
-Requires-Dist: rich>=13.9.4
-Requires-Dist: tavily-python>=0.5.0
-Requires-Dist: temporalio>=1.9.0
-Description-Content-Type: text/markdown
-
-# flock
-
-white duck flock (engl. Herde/Schwarm) ist ein KI-gestütztes Agentenframework. Agenten sind Applikationen die autark und autonom entscheiden wie sie ein Problem lösen, und je nach konfiguration auch selber entscheiden wie sie untereinander kommunizieren. Ein zusammenschluss mehrerer Agenten ist ein Agentensystem.
-
-Wir dachten da vielleicht als Logo einfach eine Herde/Schwarm an Freds, oder ähnlich wie Huggingface an einen James Bond Fred (vgl. https://huggingface.co/docs/smolagents/en/index) oder natürlich auch gerne eine Herde an James Bond Freds!
-
-
-White Duck Flock (engl. Herde/Schwarm) ist ein KI-gestütztes Agentenframework. Agenten sind Applikationen, die autark und autonom entscheiden, wie sie ein Problem lösen – und je nach Konfiguration auch selbst bestimmen, wie sie untereinander kommunizieren. Ein Zusammenschluss mehrerer Agenten bildet ein Agentensystem.
-
-Als Logo dachten wir vielleicht an eine Herde/Schwarm von Freds – oder, ähnlich wie Hugging Face, an einen James-Bond-Fred (vgl. https://huggingface.co/docs/smolagents/en/index). Alternativ natürlich auch gerne eine ganze Herde an James-Bond-Freds!
-
-
-
-
-```python
-MODEL = "openai/gpt-4o"
-
-async def main():
- 
-    #--------------------------------
-    # Create the flock and context
-    #--------------------------------
-    # The flock is the place where all the agents are at home
-    # The context is everything that happened in the flock
-    flock, context = Flock.create()
-
-    #--------------------------------
-    # Create an agent
-    #--------------------------------
-    # The Flock doesn't believe in prompts (see the readme for more info)
-    # The Flock just declares what agents get in and what agents produce
-    # bloggy takes in a blog_idea and outputs a funny_blog_title and blog_headers
-    bloggy = DeclarativeAgent(
-        name="bloggy",
-        input="blog_idea",
-        output="funny_blog_title, blog_headers",
-        model=MODEL
-    )
-    # Let's add bloggy to the flock
-    flock.add_agent(bloggy)
-
-    #--------------------------------
-    # Run the flock
-    #--------------------------------
-    # By giving the flock a start_agent and an input, we can run the flock
-    # local_debug makes it easier to debug the flock
-    result = await flock.run_async(
-        context=context,
-        start_agent=bloggy,
-        input="a blog about cats",
-        local_debug=True
-    )
-    # earn the fruits of the flock's labor
-    print(result)
-
-```
-
-Problems with other agent frameworks
-
-- Instead of writing software you need to write pages long natural language prompts
-- One crash and your whole agent system is dead
-- Demand having your system be a real DAG and a real state machine
-
-How Flock tries to solve it:
-
-- Just declare what your agents get ind, and what they should return
-- First grade temporalio support. Retry, Error, Timeout etc etc are somethi
-- Chain your agents together in any kind you want
-
-## Philosophy & Design Principles
-
-### Say goodbye to prompting
-
-Sometimes you see agents with a 200 lines of text system prompt.
-How do evaluate if this is the most optimal prompt for your use case? How would changes affect the performance?
-Questions for there is no easy answer.
-
-How does a good prompt look like? What happens with your prompt if you switch models?
-
-With flock you just tell an agent what kind of input it gets, and what it should output. Done. Easy peasy.
-
-The philosophy behind this approach is simple: by focusing on the interface (inputs and outputs) rather than implementation details (prompts), we create more maintainable and adaptable systems. This declarative approach means:
-- Your agents are model-agnostic
-- Behavior can be tested and validated objectively
-- Changes are localized and predictable
-- Integration with other systems becomes straightforward
-
-### Testable
-
-Reducing the need for fuzzy natural language to a minimum agents become easily testable, evaluable.
-Flock comes with tools to know exactly how good your agents and therefore the agent system is performing.
-
-This focus on testability isn't just about catching bugs - it's about building confidence in your AI systems:
-- Clear input/output contracts make unit testing straightforward
-- Type safety ensures data consistency
-- Performance metrics are built into the framework
-- Behavior can be validated systematically
-
-### Production ready
-
-Would you run your agent system in critical environments? The answer is probably no, since with most frameworks one dead endpoint or uncatched exception will break the whole agent system.
-
-Flock uses Temporal as its workflow engine which comes with battle-hardened retry, failure, exception options.
-
-This production-readiness is achieved through several key design decisions:
-- Temporal workflow engine for durability and reliability
-- Strong typing for predictable behavior
-- Modular architecture for maintainability
-- Built-in monitoring and debugging capabilities
-
-## Core Features
-
-- **Declarative Agent System**: Define agents with clear input/output specifications and optional tool capabilities
-- **Temporal Workflow Integration**: Built-in support for durable execution and state management using Temporal
-- **Tool Integration**: Easy integration of external tools like web search, code evaluation, and math computation
-- **Type Safety**: Strong typing support for agent inputs and outputs
-- **DSPy Integration**: Seamless integration with DSPy for LLM interactions
-- **Flexible Architecture**: Support for agent chaining, hand-offs, and complex workflows
-
-## Architecture and Flow
-
-![alt text](docs/img/charts/agent_workflow_inv.png) 
-
-
-![alt text](docs/img/charts/core_architecture_inv.png) 
-
-## Requirements
-
-Nothing. Temporal is not needed for development but recommended
-
-Either clone https://github.com/temporalio/docker-compose and up the compose
-
-or install the temporal cli
-
-https://docs.temporal.io/cli
-
-## Installation
-
-```bash
-pip install flock
-```
-
-## Quick Start
-
-Here's a simple example of creating and using an agent:
-
-```python
-import asyncio
-from flock.core.agents.declarative_agent import DeclarativeAgent
-from flock.core.flock import Flock
-
-async def main():
-    # Initialize Flock
-    agent_runner = Flock()
-
-    # Create a simple agent
-    agent = DeclarativeAgent(
-        name="blog_title_agent",
-        input="blog_idea",
-        output="funny_blog_title",
-    )
-    agent_runner.add_agent(agent)
-
-    # Run the agent
-    result = await agent_runner.run_async(
-        start_agent=agent,
-        input="a blog about cats",
-        local_debug=True,
-    )
-    print(result)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Web Application
-
-![alt text](docs/img/app.png)
-
-Flock comes with a built-in web interface for managing and monitoring your agents. The web app provides a rich, interactive environment for working with your agent systems.
-
-TODO: Expand
-
-### Running the Web App
-
-```bash
-# After installing flock
-flock
-# Or with uv
-uv run flock
-```
-
-### Features
-
-- **Dashboard**: Overview of your agent systems and their status
-- **Agent Management**: 
-  - List and filter agents
-  - View agent details and configuration
-  - Monitor production readiness
-  - Track agent history
-- **Agent Systems**: Manage complex agent workflows and interactions
-- **History**: View execution history and results
-- **Tools**: Access and manage available tools
-- **Playground**: Interactive environment for testing agents
-- **Settings**: Configure system preferences and integrations
-
-### Technical Details
-
-The web application is built with:
-- FastHTML for UI components
-- MonsterUI for enhanced UI elements
-- Interactive features using D3.js and interact.js
-- Real-time updates and monitoring
-- Responsive design for different screen sizes
-
-### Interface Structure
-
-```
-Web Interface
-├── Sidebar Navigation
-│   ├── Dashboard
-│   ├── Agents
-│   ├── Agent Systems
-│   ├── History
-│   ├── Tools
-│   ├── Playground
-│   └── Settings
-├── Main Content Area
-│   ├── Agent List
-│   └── Agent Details
-└── Interactive Features
-    ├── Theme Switching
-    ├── Search Functionality
-    └── Real-time Updates
-```
-
-## Advanced Usage
-
-### Agents with Tools
-
-Agents can use tools to interact with external systems:
-
-```python
-from flock.core.tools import basic_tools
-
-agent = DeclarativeAgent(
-    name="research_agent",
-    input="research_topic",
-    output="research_result",
-    tools=[basic_tools.web_search_tavily],
-)
-```
-
-### Type-Safe Outputs
-
-Define complex output types for structured responses:
-
-```python
-agent = DeclarativeAgent(
-    name="analysis_agent",
-    input="long_text",
-    output="""
-        title: str,
-        headings: list[str],
-        entities_and_metadata: list[dict[str, str]],
-        type: Literal['news', 'blog', 'opinion piece', 'tweet']
-    """,
-)
-```
-
-### Agent Chaining
-
-Create chains of agents that can hand off tasks:
-
-```python
-# First agent in chain
-project_plan_agent = DeclarativeAgent(
-    name="project_plan_agent",
-    input="project_idea",
-    output="catchy_project_name, project_pitch, project_plan_headings: list[str]",
-    tools=[basic_tools.web_search_tavily, basic_tools.code_eval],
-)
-
-# Second agent in chain
-content_agent = DeclarativeAgent(
-    name="content_agent",
-    input="context,project_plan_agent.project_plan_headings.items",
-    output="project_plan_heading, project_plan_content_for_heading",
-)
-
-# Set up hand-off
-project_plan_agent.hand_off = content_agent
-```
-
-## Core Components
-
-### Flock Class
-
-The main orchestrator that manages agent creation and execution:
-- Handles agent registration
-- Manages workflow execution
-- Supports both local debugging and distributed execution
-
-### DeclarativeAgent
-
-Base class for creating agents with:
-- Input/output specifications
-- Tool integration
-- Type validation
-- Hand-off capabilities
-
-### Workflow System
-
-Built on Temporal for:
-- Durable execution
-- State management
-- Error handling
-- Activity tracking
-
-### Tools
-
-Built-in tools include:
-- Web search (via Tavily)
-- Math evaluation
-- Code execution
-- Extensible tool system for custom integrations
-
-## Architecture
-
-```
-Flock Framework
-├── Core
-│   ├── Agents
-│   │   ├── DeclarativeAgent
-│   │   └── Agent Registry
-│   ├── Tools
-│   │   └── Basic Tools
-│   └── Flock Manager
-├── Workflow
-│   ├── Activities
-│   ├── Temporal Setup
-│   └── Workflow Definitions
-└── App
-    └── Components
-```
-
-## Development
-
-### Prerequisites
-
-- Python 3.12+
-- Temporal server running locally (for workflow features)
-- Required API keys (e.g., Tavily for web search)
-
-### Setup
-
-1. Clone the repository:
-```bash
-git clone https://github.com/yourusername/flock.git
-cd flock
-```
-
-2. Create a virtual environment:
-```bash
-python -m venv .venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-```
-
-3. Install dependencies:
-```bash
-pip install -e .
-```
-
-### Running Tests
-
-```bash
-pytest tests/
-```
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-This project is licensed under the terms of the LICENSE file included in the repository.
-
-## Acknowledgments
-
-- Built with [DSPy](https://github.com/stanfordnlp/dspy)
-- Uses [Temporal](https://temporal.io/) for workflow management
-- Integrates with [Tavily](https://tavily.com/) for web search capabilities
-- Web interface built with FastHTML and MonsterUI
-
-## Evolution & Future Direction
-
-Flock was born from the realization that current agent frameworks often prioritize flexibility at the cost of reliability and maintainability. The framework's design decisions reflect this focus:
-
-### Why Declarative?
-The declarative approach wasn't just a stylistic choice - it was a deliberate decision to separate what agents do from how they do it. This separation means:
-- Agents can be optimized independently of their interface
-- Different LLM backends can be swapped without changing agent definitions
-- Testing and validation become straightforward
-- Integration with existing systems is simplified
-
-### Why Temporal?
-Using Temporal as the workflow engine was crucial for production reliability:
-- Automatic retry on failures
-- Built-in state management
-- Scalable execution
-- Detailed execution history
-- Production-grade monitoring
-
-### Future Plans
-The framework is actively evolving with several key areas of focus:
-- Enhanced type system for more complex agent interactions
-- Expanded tool ecosystem
-- Improved optimization capabilities
-- Advanced monitoring and debugging features
-- Extended testing and validation tools
-
-Join us in building the future of reliable, production-ready AI agent systems!

flock_core-0.1.1.dist-info/RECORD

@@ -1,48 +0,0 @@
-flock/__init__.py,sha256=xbfYMDyjxWYPIzfiMjuuA7zMST-cPVU3wsfFm8kPuJM,129
-flock/agents/__init__.py,sha256=pIcDAbFNP6CX3UH0W5tT1WZ06AW9RH1d1h9VTkCl-fI,95
-flock/agents/batch_agent.py,sha256=MIet5iGDuW5OmHdCas3DuLt7R4e0YQa7eDqdJ5oQAuI,8282
-flock/agents/declarative_agent.py,sha256=KHdobQOpCLJQqBY4gWL2tx6hYI2k_yjEal5RoZp2Uic,7560
-flock/agents/loop_agent.py,sha256=2ajHqNWoRyStGoqLKgkaCFcPCD-EPSyr0RHGFsM5K8I,7392
-flock/agents/trigger_agent.py,sha256=4LpfJ7xgDGAZXjS7_tPfMfLmbZwVLOe8YhikoZOg_og,8224
-flock/agents/user_agent.py,sha256=PexPzGY9S3tmm0s8WvdKf8C89ONMJdpO8tvw3zRpCjo,8575
-flock/app/hive_app.py,sha256=vNyZ3I8PZ_M-CO7joc9XBqdBOEKrxP761AQKX_Fzkv4,2621
-flock/app/components/__init__.py,sha256=wEOcF89JLUdjrOXsODZ-iADxasHBluaW7U8IxxIX3Ak,369
-flock/app/components/history_grid.py,sha256=kbUNdHq_DlhYM2zy_j1kOksvEEhyq-68YnJmFb3CLb0,5629
-flock/app/components/history_grid_alt.py,sha256=V2iJ53aPEpb2_U4Eaat8g0LqgTG3xaCWBXCaUR7ZQWk,6739
-flock/app/components/sidebar.py,sha256=WF_69gie1z7Wjfbdt7rESuhk4wjPle0z8P8IEVGeUog,558
-flock/app/components/theme.py,sha256=tBOi0Fgewke-l3Ifp-An-HRNEsinEFxtX1xYb8w62PE,201
-flock/app/components/util.py,sha256=u_kAo1L_hF0LiHm4gdkRxJUlWJWPU3fmh8o3ZnYNec0,415
-flock/app/components/charts/agent_workflow.py,sha256=XVxMnHsx8YY5jPQ7wbp_36dMPxw3dTkwH1aN3e-Cxrg,10862
-flock/app/components/charts/core_architecture.py,sha256=YqENUkIR8913JvHuYfY-V2vymelDJkH1wZkEckmEqY4,10865
-flock/app/components/charts/tool_system.py,sha256=ExrtqBrEkoXiVCHo424NB3TeMhRb3V_8L3ZIOBiDDvM,10384
-flock/app/html/d3.html,sha256=Wb1dFBmqXeiH3Ol2g3GeyPkvlyGsoOKSUOaEk3_2uUw,5404
-flock/app/modules/__init__.py,sha256=DrK6C1UJpKJt980WqpQPN-w3dyslwfRp4GGK8AefJlg,279
-flock/app/modules/about.py,sha256=BZT6beln4opwk4bhbn6wi1oLQTezcdg3vHmEM7OiTeA,438
-flock/app/modules/agent_detail.py,sha256=JBuAhtTpnrxbq8n0VeQM9FNMd1jZ3iiMQzp1aehkRvo,3128
-flock/app/modules/agent_list.py,sha256=-f6qlNzJkH6Hhd306-Mp1JrWkZQjZf1xUyCzKRXob2Q,2311
-flock/app/modules/playground.py,sha256=CiqrDLUd30eVdoyWsQNCGm-Qsf-O3GE7vvyv7jOamMY,9980
-flock/app/modules/settings.py,sha256=HmVzoV6A6QjYdmMfw4vpF1w8V5TIqRusQhQQhEQCQKw,2970
-flock/core/__init__.py,sha256=tSc7Ix_UVOqsc7VTkPq7-3wGUPbRUeYoLIMADnpisGo,291
-flock/core/agent.py,sha256=TIYlz5hX-ocd7ag1Ixa9RU5i9B59R-tEb11_qDYYj40,6445
-flock/core/agent_registry.py,sha256=OegRMXbE7ebptnF_PcEIewjcNk1OUOxx_2h2K8-1ubc,5672
-flock/core/context.py,sha256=s-Nci1Qp1px9SUwA5Xx66VvIDFlMA1_jcsNaJbsHGuM,11454
-flock/core/context_vars.py,sha256=iP3RnOP0YJtPpMSwbixbpxOm7PmzhiLPJdqw6INRVqc,242
-flock/core/flock.py,sha256=Fa4VrjjniwIxrBaDA9zco6lfz0LlqYkQckp2xLU__fE,8241
-flock/core/serializable.py,sha256=mbsNDwTD-3bBUzfAi7yXR55VhGbYt0XZq44Me1wtBIs,7404
-flock/core/config/declarative_agent_config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/core/handoff/handoff_base.py,sha256=iXHhpGojrLT3nUGWLuGog5EjsPq50GJ2aKV-AmRRO-I,267
-flock/core/logging/__init__.py,sha256=nYatDGaN5pSyu2eudnhREbS7WRIKFR7ysMTtL7cfupU,605
-flock/core/logging/error_handler.py,sha256=cw2XKGMi-O1HtGjN0bbB46onolW0aAygX3qu2eqB_IE,2602
-flock/core/logging/formatters.py,sha256=Z_wHK7qjIPW2oEFcqkSZm0-ibHv4AizbSZSStsRTSJ0,4747
-flock/core/logging/handlers.py,sha256=C6-P10RuZ_y2odtRipOwCv5r1ezIWBvNnMKcWz6onQ4,4235
-flock/core/logging/logger.py,sha256=w0TMb1jRw25FJKGhcmabXdXKZylubeNDJr5cR2TWBIk,4234
-flock/core/tools/basic_tools.py,sha256=9Qj_Nl5QACvHeWSt6k9pfBEcBqsO--D6XcSuiJWF1Rc,2082
-flock/workflow/activities.py,sha256=YZ0YYJTYPSmoTkpiY7x_pzwY3OpkkWm3ye9g6n-bFO4,5398
-flock/workflow/agent_activities.py,sha256=Shwiphd5Yi3VwbQN9SCuEsuhe6zJxIn0gBwMIpRZh-8,1134
-flock/workflow/temporal_setup.py,sha256=if3fmdy9cxoKGOZlbIfizLrZBYRGn2soMOBYLtP1mPI,1126
-flock/workflow/workflow.py,sha256=JTWFGE2_JltOd2PPJXlYfSeBlwbTQqRKLMszVdeqia0,1813
-flock_core-0.1.1.dist-info/METADATA,sha256=sy9f6S-CEemZi0whRjOjlcPy4wvrU68yWVCiKUAilsU,13656
-flock_core-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.1.1.dist-info/entry_points.txt,sha256=BoHLk1jgBHMsiQNA8h6lEe8B-dcq3Hqh3sbJGSmavZs,51
-flock_core-0.1.1.dist-info/licenses/LICENSE,sha256=eukczQf9y9W2_CLyGK-S06qMcU5zkTF39gJCjspsDA0,1093
-flock_core-0.1.1.dist-info/RECORD,,

flock_core-0.1.1.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-flock = flock.app.flock_app:main