1
2
from core import Agent
from manas_ai.models import Tool

1
2
3
4
5
6
7
def __init__(
    self,
    name: str,
    llm: Optional[LLM] = None,
    system_prompt: Optional[str] = None,
    memory: Optional[Dict[str, Any]] = None
)

1
async def think(self, context: Dict[str, Any]) -> Dict[str, Any]

1
async def act(self, decision: Dict[str, Any]) -> Dict[str, Any]

1
async def observe(self, result: Dict[str, Any]) -> Dict[str, Any]

1
async def process(self, inputs: Dict[str, Any]) -> Dict[str, Any]

1
def add_tool(self, tool: Tool) -> None

1
def remove_tool(self, tool_name: str) -> None

1
def get_tool(self, tool_name: str) -> Optional[Tool]

1
def remember(self, key: str, value: Any) -> None

1
def recall(self, key: str) -> Optional[Any]

1
def forget(self, key: str) -> None

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Create a simple agent
agent = Agent(
    name="assistant",
    llm=LLM.from_provider("openai", model_name="gpt-4"),
    system_prompt="You are a helpful assistant."
)

# Initialize and use
await agent.initialize()
try:
    result = await agent.process({
        "prompt": "What is quantum computing?"
    })
    print(result["response"])
finally:
    await agent.cleanup()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Create tools
calculator = Tool(
    name="calculator",
    description="Performs calculations",
    function=lambda x: eval(x)
)

search = Tool(
    name="web_search",
    description="Searches the web",
    function=async_search_function
)

# Create agent with tools
agent = Agent(
    name="researcher",
    llm=model,
    system_prompt=(
        "You are a research assistant with access to tools. "
        "Use the calculator for math and search for information."
    )
)

# Add tools
agent.add_tool(calculator)
agent.add_tool(search)

# Process with tools
result = await agent.process({
    "prompt": "What is 157 * 23? Also, find information about Mars."
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class ResearchAgent(Agent):
    """Specialized research agent with custom behavior."""
    
    async def think(self, context: Dict[str, Any]) -> Dict[str, Any]:
        # Custom thinking process
        topic = context["prompt"]
        return {
            "plan": [
                f"Research {topic}",
                "Analyze findings",
                "Summarize results"
            ],
            "next_action": "research",
            "parameters": {"topic": topic}
        }
    
    async def act(self, decision: Dict[str, Any]) -> Dict[str, Any]:
        # Custom action execution
        if decision["next_action"] == "research":
            return await self.do_research(decision["parameters"])
        # ... handle other actions
    
    async def observe(self, result: Dict[str, Any]) -> Dict[str, Any]:
        # Custom learning/observation
        self.remember(
            f"research_{result['topic']}",
            result["findings"]
        )
        return {
            "learned": True,
            "summary": result["summary"]
        }

# Usage
agent = ResearchAgent(
    name="specialized_researcher",
    llm=model,
    system_prompt="You are a specialized research agent."
)