Autono

Installation

• From PYPI

    pip install -U autono
    

• From Github

Get access to unreleased features.

    pip install git+https://github.com/vortezwohl/Autono.git
    

Quick Start

To start building your own agent, follow the steps listed.

1. set environmental variable OPENAI_API_KEY

    # .env
    OPENAI_API_KEY=sk-...
    

1. import required dependencies

• Agent lets you instantiate an agent.

• Personality is an enumeration class used for customizing personalities of agents.

• Personality.PRUDENT makes the agent's behavior more cautious.

• Personality.INQUISITIVE encourages the agent to be more proactive in trying and exploring.

• get_openai_model gives you a BaseChatModel as thought engine.

• @ability(brain: BaseChatModel, cache: bool = True, cache_dir: str = '') is a decorator which lets you declare a function as an Ability.

• @agentic(agent: Agent) is a decorator which lets you declare a function as an AgenticAbility.

    from autono import (
        Agent,
        Personality,
        get_openai_model,
        ability,
        agentic
    )
    

1. declare functions as basic abilities

    @ability
    def calculator(expr: str) -> float:
        # this function only accepts a single math expression
        return simplify(expr)

    @ability
    def write_file(filename: str, content: str) -> str:
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)
        return f'{content} written to {filename}.'
    

1. instantiate an agent

You can grant abilities to agents while instantiating them.

    model = get_openai_model()
    agent = Agent(abilities=[calculator, write_file], brain=model, name='Autono', personality=Personality.INQUISITIVE)
    

• You can also grant more abilities to agents later:

        agent.grant_ability(calculator)
        

or

        agent.grant_abilities([calculator])
        

• To deprive abilities:

        agent.deprive_ability(calculator)
        

or

        agent.deprive_abilities([calculator])
        

    agent.change_personality(Personality.PRUDENT)
    

1. assign a request to your agent

    agent.assign("Here is a sphere with radius of 9.5 cm and pi here is 3.14159, find the area and volume respectively then write the results into a file called 'result.txt'.")
    

1. leave the rest to your agent

    response = agent.just_do_it()
    print(response)
    

autono also supports multi-agent collaboration scenario, declare a function as agent calling ability with @agentic(agent: Agent), then grant it to an agent. See example.

Integration with [MCP](https://github.com/modelcontextprotocol)

I provide McpAgent to support tool calls based on the MCP protocol. Below is a brief guide to integrating McpAgent with mcp.stdio_client:

1. import required dependencies

• McpAgent allows you to instantiate an agent capable of accessing MCP tools.

• StdioMcpConfig is an alias for mcp.client.stdio.StdioServerParameters and serves as the MCP server connection configuration.

• @mcp_session(mcp_config: StdioMcpConfig) allows you to declare a function as an MCP session.

• sync_call allows you to synchronizedly call a coroutine function.

    from autono import (
        McpAgent,
        get_openai_model,
        StdioMcpConfig,
        mcp_session,
        sync_call
    )
    

1. create an MCP session

• To connect with a stdio based MCP server, use StdioMcpConfig.

        mcp_config = StdioMcpConfig(
            command='python',
            args=['./my_stdio_mcp_server.py'],
            env=dict(),
            cwd='./mcp_servers'
        )
        

A function decorated with @mcp_session will receive an MCP session instance as its first parameter. A function can be decorated with multiple @mcp_session decorators to access sessions for different MCP servers.

        @sync_call
        @mcp_session(mcp_config)
        async def run(session, request: str) -> str:
            ...
        

• To connect via HTTP with a SSE based MCP server, just provide the URL.

        @sync_call
        @mcp_session('http://localhost:8000/sse')
        async def run(session, request: str) -> str:
            ...
        

        @sync_call
        @mcp_session('ws://localhost:8000/message')
        async def run(session, request: str) -> str:
            ...
        

1. create an McpAgent instance within the MCP session

After creating McpAgent, you need to call the fetch_abilities() method to retrieve tool configurations from the MCP server.

    @sync_call
    @mcp_session(mcp_config)
    async def run(session, request: str) -> str:
        mcp_agent = await McpAgent(session=session, brain=get_openai_model()).fetch_abilities()
        ...
    

1. assign tasks to the McpAgent instance and await execution result

    @sync_call
    @mcp_session(mcp_config)
    async def run(session, request: str) -> str:
        mcp_agent = await McpAgent(session=session, brain=get_openai_model()).fetch_abilities()
        result = await mcp_agent.assign(request).just_do_it()
        return result.conclusion
    

1. call the function

    if __name__ == '__main__':
        ret = run(request='What can you do?')
        print(ret)
    

I also provide the complete MCP agent test script. See example.