mojentic 0.6.2__py3-none-any.whl → 0.7.2__py3-none-any.whl

_examples/async_dispatcher_example.py

@@ -0,0 +1,241 @@
+"""
+Example script demonstrating how to use the AsyncDispatcher, BaseAsyncAgent, and AsyncAggregatorAgent.
+
+This script shows how to create and use asynchronous agents with the AsyncDispatcher.
+"""
+
+import asyncio
+from pathlib import Path
+from typing import List
+
+from pydantic import BaseModel, Field
+
+from mojentic.agents.async_aggregator_agent import AsyncAggregatorAgent
+from mojentic.agents.async_llm_agent import BaseAsyncLLMAgent
+from mojentic.agents.base_async_agent import BaseAsyncAgent
+from mojentic.async_dispatcher import AsyncDispatcher
+from mojentic.event import Event, TerminateEvent
+from mojentic.llm import LLMBroker
+from mojentic.llm.gateways.models import LLMMessage, MessageRole
+from mojentic.router import Router
+
+
+# Define some example events
+class TextEvent(Event):
+    text: str = Field(..., description="The text content of the event")
+
+
+class AnalysisEvent(Event):
+    analysis: str = Field(..., description="The analysis of the text")
+
+
+class SummaryEvent(Event):
+    summary: str = Field(..., description="The summary of the text")
+
+
+class CombinedResultEvent(Event):
+    text: str = Field(..., description="The original text")
+    analysis: str = Field(..., description="The analysis of the text")
+    summary: str = Field(..., description="The summary of the text")
+    combined: str = Field(..., description="The combined result")
+
+
+# Define response models for LLM agents
+class AnalysisResponse(BaseModel):
+    analysis: str = Field(..., description="The analysis of the text")
+
+
+class SummaryResponse(BaseModel):
+    summary: str = Field(..., description="The summary of the text")
+
+
+class CombinedResponse(BaseModel):
+    combined: str = Field(..., description="The combined result of the analysis and summary")
+
+
+# Define some example agents
+class TextAnalyzerAgent(BaseAsyncLLMAgent):
+    """
+    An agent that analyzes text and produces an analysis.
+    """
+
+    def __init__(self, llm: LLMBroker):
+        super().__init__(
+            llm=llm,
+            behaviour="You are a text analysis assistant. Your job is to provide a detailed analysis of the given text, including key themes, structure, and notable elements.",
+            response_model=AnalysisResponse
+        )
+
+    async def receive_event_async(self, event: Event) -> List[Event]:
+        if isinstance(event, TextEvent):
+            prompt = f"""
+Please analyze the following text in detail. Consider:
+- Main themes and topics
+- Structure and organization
+- Key points and arguments
+- Style and tone
+- Intended audience
+- Any notable or unique elements
+
+Text to analyze:
+{event.text[:1000]}... (text truncated for brevity)
+"""
+            response = await self.generate_response(prompt)
+            return [AnalysisEvent(source=type(self), correlation_id=event.correlation_id, analysis=response.analysis)]
+        return []
+
+
+class TextSummarizerAgent(BaseAsyncLLMAgent):
+    """
+    An agent that summarizes text.
+    """
+
+    def __init__(self, llm: LLMBroker):
+        super().__init__(
+            llm=llm,
+            behaviour="You are a text summarization assistant. Your job is to provide concise, accurate summaries of texts while preserving the key information and main points.",
+            response_model=SummaryResponse
+        )
+
+    async def receive_event_async(self, event: Event) -> List[Event]:
+        if isinstance(event, TextEvent):
+            prompt = f"""
+Please provide a concise summary of the following text. The summary should:
+- Capture the main points and key information
+- Be significantly shorter than the original text
+- Maintain the original meaning and intent
+- Be clear and coherent
+- Exclude unnecessary details
+
+Text to summarize:
+{event.text[:1000]}... (text truncated for brevity)
+"""
+            response = await self.generate_response(prompt)
+            return [SummaryEvent(source=type(self), correlation_id=event.correlation_id, summary=response.summary)]
+        return []
+
+
+class ResultCombinerAgent(AsyncAggregatorAgent):
+    """
+    An agent that combines the analysis and summary of a text using LLM.
+    """
+
+    def __init__(self, llm: LLMBroker):
+        super().__init__(event_types_needed=[TextEvent, AnalysisEvent, SummaryEvent])
+        self.llm = llm
+        self.behaviour = "You are an assistant that combines text analysis and summaries into a comprehensive report."
+        self.response_model = CombinedResponse
+
+    async def process_events(self, events):
+        # Extract the events
+        text_event = next((e for e in events if isinstance(e, TextEvent)), None)
+        analysis_event = next((e for e in events if isinstance(e, AnalysisEvent)), None)
+        summary_event = next((e for e in events if isinstance(e, SummaryEvent)), None)
+
+        if text_event and analysis_event and summary_event:
+            # Use LLM to create a sophisticated combination
+            prompt = f"""
+I have analyzed and summarized a text. Please combine these into a comprehensive report.
+
+Original Text (excerpt): {text_event.text[:300]}... (text truncated for brevity)
+
+Analysis: {analysis_event.analysis}
+
+Summary: {summary_event.summary}
+
+Please create a well-structured, insightful report that integrates the analysis and summary, 
+highlighting the most important aspects of the text. The report should provide a comprehensive 
+understanding of the text's content, structure, and significance.
+"""
+            # Create a temporary LLM agent to generate the response
+            messages = [
+                LLMMessage(role=MessageRole.System, content=self.behaviour),
+                LLMMessage(role=MessageRole.User, content=prompt)
+            ]
+
+            # Generate the response
+            import asyncio
+            response_json = await asyncio.to_thread(
+                self.llm.generate_object,
+                messages=messages,
+                object_model=self.response_model
+            )
+
+            combined = response_json.combined
+
+            return [CombinedResultEvent(
+                source=type(self),
+                correlation_id=text_event.correlation_id,
+                text=text_event.text,
+                analysis=analysis_event.analysis,
+                summary=summary_event.summary,
+                combined=combined
+            )]
+        return []
+
+
+class ResultOutputAgent(BaseAsyncAgent):
+    """
+    An agent that receives the CombinedResultEvent, outputs the result to the user,
+    and emits a TerminateEvent to exit the event loop.
+    """
+
+    async def receive_event_async(self, event: Event) -> List[Event]:
+        if isinstance(event, CombinedResultEvent):
+            # Output the result to the user
+            print("\n=== FINAL ANSWER ===")
+            print(event.combined)
+            print("===================\n")
+
+            # Emit a TerminateEvent to exit the event loop
+            return [TerminateEvent(source=type(self), correlation_id=event.correlation_id)]
+        return []
+
+
+async def main():
+    """
+    Main function that demonstrates the usage of AsyncDispatcher and async agents.
+    """
+    # Initialize the LLM broker with the same model as in async_llm_example
+    llm = LLMBroker(model="qwen3:30b-a3b-q4_K_M")
+
+    # Create a router and register agents
+    router = Router()
+
+    # Create agents with LLM
+    analyzer = TextAnalyzerAgent(llm)
+    summarizer = TextSummarizerAgent(llm)
+    combiner = ResultCombinerAgent(llm)
+    output_agent = ResultOutputAgent()
+
+    # Register agents with the router
+    router.add_route(TextEvent, analyzer)
+    router.add_route(TextEvent, summarizer)
+    router.add_route(TextEvent, combiner)
+    router.add_route(AnalysisEvent, combiner)
+    router.add_route(SummaryEvent, combiner)
+    router.add_route(CombinedResultEvent, output_agent)
+
+    # Create and start the dispatcher
+    dispatcher = await AsyncDispatcher(router).start()
+
+    # Create a text event
+    with open(Path.cwd().parent.parent / "README.md", "r") as f:
+        text = f.read()
+    event = TextEvent(source=type("ExampleSource", (), {}), text=text)
+
+    # Dispatch the event
+    dispatcher.dispatch(event)
+
+    # Wait for all events in the queue to be processed
+    print("Waiting for all events to be processed...")
+    queue_empty = await dispatcher.wait_for_empty_queue(timeout=10)
+    if not queue_empty:
+        print("Warning: Not all events were processed within the timeout period.")
+
+    # Stop the dispatcher
+    await dispatcher.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

_examples/async_llm_example.py

@@ -0,0 +1,236 @@
+"""
+Example script demonstrating how to use the AsyncDispatcher with BaseAsyncLLMAgent.
+
+This script shows how to create and use asynchronous LLM agents with the AsyncDispatcher.
+"""
+
+import asyncio
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from mojentic.agents.async_aggregator_agent import AsyncAggregatorAgent
+from mojentic.agents.async_llm_agent import BaseAsyncLLMAgent
+from mojentic.async_dispatcher import AsyncDispatcher
+from mojentic.context.shared_working_memory import SharedWorkingMemory
+from mojentic.event import Event
+from mojentic.llm import LLMBroker
+from mojentic.router import Router
+
+
+# Define some example events
+class QuestionEvent(Event):
+    question: str = Field(..., description="The question to answer")
+
+
+class FactCheckEvent(Event):
+    question: str = Field(..., description="The original question")
+    facts: List[str] = Field(..., description="The facts related to the question")
+
+
+class AnswerEvent(Event):
+    question: str = Field(..., description="The original question")
+    answer: str = Field(..., description="The answer to the question")
+    confidence: float = Field(..., description="The confidence level of the answer (0-1)")
+
+
+class FinalAnswerEvent(Event):
+    question: str = Field(..., description="The original question")
+    answer: str = Field(..., description="The final answer to the question")
+    facts: List[str] = Field(..., description="The facts used to answer the question")
+    confidence: float = Field(..., description="The confidence level of the answer (0-1)")
+
+
+# Define response models for LLM agents
+class FactCheckResponse(BaseModel):
+    facts: List[str] = Field(..., description="The facts related to the question")
+
+
+class AnswerResponse(BaseModel):
+    answer: str = Field(..., description="The answer to the question")
+    confidence: float = Field(..., description="The confidence level of the answer (0-1)")
+
+
+# Define some example agents
+class FactCheckerAgent(BaseAsyncLLMAgent):
+    """
+    An agent that checks facts related to a question.
+    """
+    def __init__(self, llm: LLMBroker):
+        super().__init__(
+            llm=llm,
+            behaviour="You are a fact-checking assistant. Your job is to provide relevant facts about a question.",
+            response_model=FactCheckResponse
+        )
+
+    async def receive_event_async(self, event: Event) -> List[Event]:
+        if isinstance(event, QuestionEvent):
+            prompt = f"Please provide relevant facts about the following question: {event.question}"
+            response = await self.generate_response(prompt)
+            return [FactCheckEvent(
+                source=type(self),
+                correlation_id=event.correlation_id,
+                question=event.question,
+                facts=response.facts
+            )]
+        return []
+
+
+class AnswerGeneratorAgent(BaseAsyncLLMAgent):
+    """
+    An agent that generates an answer to a question.
+    """
+    def __init__(self, llm: LLMBroker):
+        super().__init__(
+            llm=llm,
+            behaviour="You are a question-answering assistant. Your job is to provide accurate answers to questions.",
+            response_model=AnswerResponse
+        )
+
+    async def receive_event_async(self, event: Event) -> List[Event]:
+        if isinstance(event, QuestionEvent):
+            prompt = f"Please answer the following question: {event.question}"
+            response = await self.generate_response(prompt)
+            return [AnswerEvent(
+                source=type(self),
+                correlation_id=event.correlation_id,
+                question=event.question,
+                answer=response.answer,
+                confidence=response.confidence
+            )]
+        return []
+
+
+class FinalAnswerAgent(AsyncAggregatorAgent):
+    """
+    An agent that combines facts and answers to produce a final answer.
+    """
+    def __init__(self, llm: LLMBroker):
+        super().__init__(event_types_needed=[FactCheckEvent, AnswerEvent])
+        self.llm = llm
+        self.final_answer_event = None
+
+    async def receive_event_async(self, event: Event) -> list:
+        print(f"FinalAnswerAgent received event: {type(event).__name__}")
+        result = await super().receive_event_async(event)
+        # Store any FinalAnswerEvent created
+        for e in result:
+            if isinstance(e, FinalAnswerEvent):
+                self.final_answer_event = e
+        return result
+
+    async def process_events(self, events):
+        print(f"FinalAnswerAgent processing events: {[type(e).__name__ for e in events]}")
+        # Extract the events
+        fact_check_event = next((e for e in events if isinstance(e, FactCheckEvent)), None)
+        answer_event = next((e for e in events if isinstance(e, AnswerEvent)), None)
+
+        if fact_check_event and answer_event:
+            print("FinalAnswerAgent has both FactCheckEvent and AnswerEvent")
+            # In a real implementation, we might use the LLM to refine the answer based on the facts
+            # For this example, we'll just combine them
+
+            # Adjust confidence based on facts
+            confidence = answer_event.confidence
+            if len(fact_check_event.facts) > 0:
+                # Increase confidence if we have facts
+                confidence = min(1.0, confidence + 0.1)
+
+            final_answer_event = FinalAnswerEvent(
+                source=type(self),
+                correlation_id=fact_check_event.correlation_id,
+                question=fact_check_event.question,
+                answer=answer_event.answer,
+                facts=fact_check_event.facts,
+                confidence=confidence
+            )
+            print(f"FinalAnswerAgent created FinalAnswerEvent: {final_answer_event}")
+            self.final_answer_event = final_answer_event
+            return [final_answer_event]
+        print("FinalAnswerAgent missing either FactCheckEvent or AnswerEvent")
+        return []
+
+    async def get_final_answer(self, correlation_id, timeout=30):
+        """
+        Get the final answer for a specific correlation_id.
+
+        Parameters
+        ----------
+        correlation_id : str
+            The correlation_id to get the final answer for
+        timeout : float, optional
+            The timeout in seconds
+
+        Returns
+        -------
+        FinalAnswerEvent or None
+            The final answer event, or None if not found
+        """
+        # First wait for all needed events
+        await self.wait_for_events(correlation_id, timeout)
+
+        # Then check if we have a final answer
+        if self.final_answer_event and self.final_answer_event.correlation_id == correlation_id:
+            return self.final_answer_event
+
+        return None
+
+
+async def main():
+    """
+    Main function that demonstrates the usage of AsyncDispatcher with async LLM agents.
+    """
+    # Initialize the LLM broker with your preferred model
+    llm = LLMBroker(model="qwen3:30b-a3b-q4_K_M")
+
+    # Create a router and register agents
+    router = Router()
+
+    # Create agents
+    fact_checker = FactCheckerAgent(llm)
+    answer_generator = AnswerGeneratorAgent(llm)
+    final_answer_agent = FinalAnswerAgent(llm)
+
+    # Register agents with the router
+    router.add_route(QuestionEvent, fact_checker)
+    router.add_route(QuestionEvent, answer_generator)
+    router.add_route(QuestionEvent, final_answer_agent)
+    router.add_route(FactCheckEvent, final_answer_agent)
+    router.add_route(AnswerEvent, final_answer_agent)
+
+    # Create and start the dispatcher
+    dispatcher = await AsyncDispatcher(router).start()
+
+    # Create a question event
+    question = "What is the capital of France?"
+    event = QuestionEvent(source=type("ExampleSource", (), {}), question=question)
+
+    # Dispatch the event
+    print("Dispatching question event")
+    dispatcher.dispatch(event)
+
+    # Give the dispatcher a moment to start processing the event
+    print("Waiting for dispatcher to start processing")
+    await asyncio.sleep(0.1)
+
+    # Wait for the final answer from the FinalAnswerAgent
+    print("Waiting for final answer from FinalAnswerAgent")
+    final_answer_event = await final_answer_agent.get_final_answer(event.correlation_id, timeout=30)
+
+    # Print the final answer
+    if final_answer_event:
+        print(f"Question: {final_answer_event.question}")
+        print(f"Answer: {final_answer_event.answer}")
+        print(f"Confidence: {final_answer_event.confidence}")
+        print("Facts:")
+        for fact in final_answer_event.facts:
+            print(f"  - {fact}")
+    else:
+        print("No FinalAnswerEvent found")
+
+    # Stop the dispatcher
+    await dispatcher.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

_examples/broker_as_tool.py

@@ -2,7 +2,7 @@ import os
 from mojentic.agents.base_llm_agent import BaseLLMAgent
 from mojentic.llm.llm_broker import LLMBroker
 from mojentic.llm.tools.date_resolver import ResolveDateTool
-from mojentic.llm.tools.file_manager import FileManager, ListFilesTool, ReadFileTool, WriteFileTool
+from mojentic.llm.tools.file_manager import FileManager, ListFilesTool, ReadFileTool, WriteFileTool, FilesystemGateway
 from mojentic.llm.tools.tool_wrapper import ToolWrapper
 
 #
@@ -15,19 +15,22 @@ temporal_specialist = BaseLLMAgent(
     behaviour="You are a historian and sociologist who focuses on sorting out temporal events, determining what happened or will happen when."
 )
 
+if not os.path.exists("local"):
+    os.mkdir("local")
+
+# Create a filesystem gateway for the local directory
+fs = FilesystemGateway(base_path="local")
+
 knowledge_specialist = BaseLLMAgent(
     llm=LLMBroker(model="llama3.3-70b-32k"),
     tools=[
-        ListFilesTool(path="local"),
-        ReadFileTool(path="local"),
-        WriteFileTool(path="local"),
+        ListFilesTool(fs),
+        ReadFileTool(fs),
+        WriteFileTool(fs),
     ],
     behaviour="You are a knowledge management agent who focuses on sorting out facts and information, able to organize elemental ideas and make connections between them. You can list files to find out where you stored information, read files to review that information, and write files to store that information for later retrieval."
 )
 
-if not os.path.exists("local"):
-    os.mkdir("local")
-
 
 
 coordinator = BaseLLMAgent(
@@ -42,14 +45,14 @@ coordinator = BaseLLMAgent(
 result = coordinator.generate_response("""
 
 I have several things I need to do this week:
-                                       
+
 - On Monday, I need to ensure that I have called Scotiabank and ordered replacement cards for my current, credit, and line of credit accounts.
 - On Wednesday, I need to drive into Toronto for work. While in Toronto I need to pick up razors. I need to make sure I see Gregg, Britney and Vikram.
 - On Thursday, I need to ensure I'm up by 7am so that I can be showered and ready for work by 9.
 - On Friday, I need to ensure that I have my laundry done and my bags packed for my trip to Ottawa.
-                                       
+
 Create me a markdown file for each day of the week, named "YYYY-MM-DD-ToDo.md" where the date is the date of that day.
 Make a list of to-do items in the markdown file, and add a section for the day's daily notes that I can fill out each day.
 """)
 
-print(result)
+print(result)