uAgents Framework

https://uagents.fetch.ai/docs
Admin
The uAgents Framework is a Python library designed to facilitate the development of autonomous...
Tokens:95,261
Snippets:510
Trust Score:9.9
Update:11 months ago
Show doc for...
Tokens:
Raw
### Uagent Startup Event Logging

Source: https://uagents.fetch.ai/docs/examples/langchain

This snippet demonstrates logging an agent's address upon its startup. The `@agent.on_event("startup")` decorator ensures that the `start` function is executed when the agent initializes, allowing for initial setup tasks such as logging the agent's public address.

```python
@agent.on_event("startup")
async def start(ctx: Context):
    ctx.logger.info(f"agent address is {agent.address}")

```

--------------------------------

### Run Interval Task Agent Script

Source: https://uagents.fetch.ai/docs/quickstart

This command executes the Python script 'interval_task.py', starting the uAgent and initiating its periodic task.

```bash
python interval_task.py
```

--------------------------------

### Frontend Setup: Install Dependencies (Shell)

Source: https://uagents.fetch.ai/docs/examples/react-web

Installs project dependencies for the React frontend using npm. This command should be run in the frontend directory after navigating to it. Ensure Node.js and npm are installed.

```shell
npm install
```

--------------------------------

### Create Project Directory and Navigate

Source: https://uagents.fetch.ai/docs/quickstart

These commands create a new directory for your agent project and change into it. This is the first step in setting up your development environment.

```bash
mkdir directory_name
cd directory_name
```

--------------------------------

### Install uAgents and Related Packages

Source: https://uagents.fetch.ai/docs/guides/langchain_agent

Installs the uAgents library, uagents-adapter, and other essential packages for building LangGraph agents. This command is typically run in a Python environment.

```bash
pip install uagents>=0.22.3 uagents-adapter>=0.2.1 langchain-openai>=0.3.14 langchain-community>=0.3.21 langgraph>=0.3.31  dotenv>=0.9.9
```

--------------------------------

### Backend Setup: Start Flask Application (Shell)

Source: https://uagents.fetch.ai/docs/examples/react-web

Starts the Flask development server. This command assumes 'app.py' is the main Flask application file and is located in the backend directory. Ensure Flask is installed and the app is configured correctly.

```shell
python app.py
```

--------------------------------

### Run Agent Client

Source: https://uagents.fetch.ai/docs/guides/langchain_agent

Starts the client agent in a separate terminal. This allows interaction with the main agent, enabling testing of the communication and functionality established by the LangGraph and uAgents setup.

```bash
python agent_client.py
```

--------------------------------

### Run ReceiverAgent Script

Source: https://uagents.fetch.ai/docs/quickstart

Executes the ReceiverAgent.py script in a terminal. This script registers on the almanac contract, starts a server, and listens for incoming messages from other agents.

```python
python ReceiverAgent.py
```

--------------------------------

### Install Fetch.ai SDK Libraries

Source: https://uagents.fetch.ai/docs/guides/search_agent

Installs the necessary Python libraries for building Fetch.ai agents, including 'uagents', 'fetchai', and 'openai'. Ensure Python is installed before running these commands.

```bash
mkdir fetchai-search-agent && cd fetchai-search-agent

pip install uagents fetchai openai
```

--------------------------------

### Define and Run a Responding Uagent

Source: https://uagents.fetch.ai/docs/examples/langchain

This snippet defines a Uagent that logs its address on startup, logs any incoming messages, and sends a response back to the sender. It uses the Agent, Context, and Model classes. The agent is funded if its balance is low, and its run method is called to start its execution.

```python
from uagents.setup import fund_agent_if_low
from uagents import Agent, Context, Model


class Message(Model):
    message: str


agent = Agent(
    name="agent 2",
    port=8001,
    seed="",
    endpoint=["http://127.0.0.1:8001/submit"],
)

fund_agent_if_low(agent.wallet.address())


@agent.on_event("startup")
async def start(ctx: Context):
    ctx.logger.info(f"agent address is {agent.address}")


@agent.on_message(model=Message)
async def message_handler(ctx: Context, sender: str, msg: Message):
    ctx.logger.info(f"Received message from {sender}: {msg.message}")

    await ctx.send(sender, Message(message="hello there"))


if __name__ == "__main__":
    agent.run()

```

--------------------------------

### Frontend Setup: Start Development Server (Shell)

Source: https://uagents.fetch.ai/docs/examples/react-web

Starts the React development server, which compiles and serves the React application. This command is typically run in the frontend directory. The application will be accessible at http://localhost:3000.

```shell
npm start
```

--------------------------------

### Python uAgent Script Structure

Source: https://uagents.fetch.ai/docs/examples/langchain

This Python snippet shows the basic structure of a uAgent script, including agent initialization, defining message models (like `Message`), setting a recipient address, and creating an agent instance. It's a foundational example for setting up communication between agents.

```python
from uagents import Agent, Context, Model
from uagents.setup import fund_agent_if_low

class Message(Model):
    message: bool

RECIPIENT_ADDRESS="agent...."

agent = Agent(
        ...

```

--------------------------------

### Initialize Project and Add uagents Dependency with Poetry

Source: https://uagents.fetch.ai/docs/examples/langchain

These commands initialize a new Python project using Poetry and add the `uagents` library as a dependency. Poetry is a dependency management and packaging tool for Python. This setup is the first step towards integrating Fetch.ai agents into your project.

```bash
poetry init
poetry add uagents

```

--------------------------------

### Run Agent on Testnet (Python)

Source: https://uagents.fetch.ai/docs/getting-started/tokens

This code snippet demonstrates the default behavior of an agent running on the testnet. It shows the log output indicating the agent's startup, registration process, and the automatic allocation of testnet funds when insufficient.

```bash
python client.py
INFO:     [agent]: Starting agent with address: agent1qftyqsedg740hfyrjpf3nlm2saf3z02sra7dn64yqqc7jktlfpg8us8us23
INFO:     [agent]: Starting server on http://0.0.0.0:8001 (Press CTRL+C to quit)
INFO:     [uagents.registration]: Registration on Almanac API successful
WARNING:  [uagents.registration]: I do not have enough funds to register on Almanac contract
INFO:     [uagents.registration]: Adding testnet funds to fetch1aatyrgyv0dcjna072fdaadsx6sennxlws3gp4w
INFO:     [uagents.registration]: Registration on Almanac API successful
INFO:     [uagents.registration]: Registering on almanac contract...
INFO:     [uagents.registration]: Registering on almanac contract...complete

```

--------------------------------

### Poetry Environment Setup for Uagents Project

Source: https://uagents.fetch.ai/docs/guides/search

Instructions for setting up a Python project environment using Poetry. This includes creating a virtual environment and installing project dependencies like httpx and uagents.

```bash
poetry shell

```

```bash
poetry add httpx uagents

```

--------------------------------

### Create Sender and Receiver Agent Python Scripts

Source: https://uagents.fetch.ai/docs/quickstart

These commands create empty Python files for the SenderAgent and ReceiverAgent. These scripts will be populated with code to enable inter-agent communication.

```bash
echo. > SenderAgent.py
echo. > ReceiverAgent.py
```

--------------------------------

### Create Python Script for Interval Task Agent

Source: https://uagents.fetch.ai/docs/quickstart

This command creates a new Python file named 'interval_task.py' using the echo command. This file will contain the code for a basic uAgent.

```bash
echo. > interval_task.py
```

--------------------------------

### Create Basic uAgent with Periodic Task (Python)

Source: https://uagents.fetch.ai/docs/quickstart

This Python script defines a simple uAgent named 'alice' that logs its name at a 2-second interval. It requires the 'uagents' library. Remember to replace 'YOUR NEW PHRASE' with a unique seed phrase.

```python
from uagents import Agent, Context

# Create an agent named Alice
alice = Agent(name="alice", seed="YOUR NEW PHRASE", port=8000, endpoint=["http://localhost:8000/submit"])

# Define a periodic task for Alice
@alice.on_interval(period=2.0)
async def say_hello(ctx: Context):
    ctx.logger.info(f'hello, my name is {alice.name}')


# Run the agent
if __name__ == "__main__":
    alice.run()

```

--------------------------------

### Python Agent Setup and Communication

Source: https://uagents.fetch.ai/docs/examples/langchain

This Python script defines two agents for document understanding. Agent one sends a PDF path and a question using the DocumentUnderstanding model. Agent two is expected to process this and return findings via the DocumentsResponse model. It includes agent initialization, message models, and event handlers for startup and message reception.

```python
from uagents import Agent, Context, Protocol, Model
from typing import List


class DocumentUnderstanding(Model):
    pdf_path: str
    question: str


class DocumentsResponse(Model):
    learnings: List


agent = Agent(
    name="find_in_pdf",
    seed="",
    port=8001,
    endpoint=["http://127.0.0.1:8001/submit"]
)

print("uAgent address: ", agent.address)
summary_protocol = Protocol("Text Summarizer")

RECIPIENT_PDF_AGENT = ""


@agent.on_event("startup")
async def on_startup(ctx: Context):
    await ctx.send(RECIPIENT_PDF_AGENT,
                   DocumentUnderstanding(pdf_path="../a-little-story.pdf", question="What's the synopsis?"))


@agent.on_message(model=DocumentsResponse)
async def document_load(ctx: Context, sender: str, msg: DocumentsResponse):
    ctx.logger.info(msg.learnings)


agent.include(summary_protocol, publish_manifest=True)
agent.run()

```

--------------------------------

### ReceiverAgent Expected Output

Source: https://uagents.fetch.ai/docs/quickstart

Shows the standard output from the ReceiverAgent script. This includes registration, server startup information, and received messages from other agents, demonstrating its role in communication.

```text
agent1qd8ymq4najh5wycvhvhcw3l5lmkgkvkrqevrs6wpp5ll0khfdq6v2cq6859
INFO:     [ReceiverAgent]: Registering on almanac contract...
INFO:     [ReceiverAgent]: Registering on almanac contract...complete
INFO:     [ReceiverAgent]: Starting server on http://0.0.0.0:8001 (Press CTRL+C to quit)
INFO:     [ReceiverAgent]: Received message from agent1qdp9j2ev86k3h5acaayjm8tpx36zv4mjxn05pa2kwesspstzj697xy5vk2a: Hello there bob.
INFO:     [ReceiverAgent]: Received message from agent1qdp9j2ev86k3h5acaayjm8tpx36zv4mjxn05pa2kwesspstzj697xy5vk2a: Hello there bob.
INFO:     [ReceiverAgent]: Received message from agent1qdp9j2ev86k3h5acaayjm8tpx36zv4mjxn05pa2kwesspstzj697xy5vk2a: Hello there bob.
```

--------------------------------

### Configure Agent for Mainnet (Python)

Source: https://uagents.fetch.ai/docs/getting-started/tokens

This Python code illustrates how to configure an agent to operate on the mainnet by specifying the 'network' parameter during agent initialization. It highlights the necessary steps for mainnet transactions.

```python
agent = Agent(name="mainnet_agent",
              seed="",
              port=8001,
              endpoint=["http://127.0.0.1:8001/submit"],
              network="mainnet"
              )

```

--------------------------------

### Complete Uagents Broadcast Example Script (Python)

Source: https://uagents.fetch.ai/docs/guides/broadcast

This is the full Python script for the Uagents broadcast example. It includes agent definitions, message models, protocol setup, agent behaviors for broadcasting and handling responses, and the bureau initialization and execution. This script can be run directly to demonstrate the inter-agent communication.

```python
from uagents import Agent, Bureau, Context, Model, Protocol

ethan = Agent(name="ethan", seed="ethan recovery phrase", port=8000, endpoint=["http://127.0.0.1:8000/submit"])
olivia = Agent(name="olivia", seed="olivia recovery phrase", port=8001, endpoint=["http://127.0.0.1:8001/submit"])
liam = Agent(name="liam", seed="liam recovery phrase", port=8002, endpoint=["http://127.0.0.1:8002/submit"])

class BroadcastExampleRequest(Model):
    pass

class BroadcastExampleResponse(Model):
    text: str

proto = Protocol(name="proto", version="1.0")

@proto.on_message(model=BroadcastExampleRequest, replies=BroadcastExampleResponse)
async def handle_request(ctx: Context, sender: str, _msg: BroadcastExampleRequest):
    await ctx.send(
        sender, BroadcastExampleResponse(text=f"Hello from {ctx.agent.name}")
    )

ethan.include(proto)
olivia.include(proto)

@liam.on_interval(period=5)
async def say_hello(ctx: Context):
    status_list = await ctx.broadcast(proto.digest, message=BroadcastExampleRequest())
    ctx.logger.info(f"Trying to contact {len(status_list)} agents.")

@liam.on_message(model=BroadcastExampleResponse)
async def handle_response(ctx: Context, sender: str, msg: BroadcastExampleResponse):
    ctx.logger.info(f"Received response from {sender}: {msg.text}")

bureau = Bureau(port=8000, endpoint="http://localhost:8000/submit")
bureau.add(ethan)
bureau.add(olivia)
bureau.add(liam)

if __name__ == "__main__":
    bureau.run()
```

--------------------------------

### Agent Definition and Initialization in Python

Source: https://uagents.fetch.ai/docs/examples/openai/swarm

Defines two SwarmAgents, 'Agent C' and 'Question generator', specifying their names and instructions. It also shows the initialization of a Bureau and adding agents to it, followed by running the bureau.

```python
swarm_agent_c = SwarmAgent(
    name="Agent C",
    instructions=helpful,
)

swarm_agent_d = SwarmAgent(
    name="Question generator",
    instructions="Create a random question to ask someone about any animal"
)


bureau = Bureau()
bureau.add(swarm_uagent)
bureau.add(trigger_uagent)
bureau.add(question_uagent)
bureau.run()
```

--------------------------------

### Backend Setup: Virtual Environment Activation (Shell)

Source: https://uagents.fetch.ai/docs/examples/react-web

Provides commands to set up and activate a Python virtual environment for the backend. This isolates project dependencies and ensures a clean development environment. Requires Python and venv to be installed.

```shell
# For Windows
venv\Scripts\activate
# For MacOS/Linux
source venv/bin/activate
```

--------------------------------

### Clone uAgents Repository and Install Dependencies (Bash)

Source: https://uagents.fetch.ai/docs/getting-started/install

Clones the uAgents GitHub repository and installs its dependencies using Poetry. This method is for installing from source code.

```bash
git clone https://github.com/fetchai/uAgents.git
cd uAgents
poetry install
poetry shell
```

--------------------------------

### Initialize Swarm and uAgents with Bureau

Source: https://uagents.fetch.ai/docs/examples/openai/swarm

This Python script initializes the Swarm client, defines multiple SwarmAgents with specific instructions and functions, and sets up uAgents (swarm_uagent, trigger_uagent, question_uagent) to interact with them. It utilizes the uAgents Bureau to manage and run these agents concurrently.

```python
from swarm import Swarm, Agent
from swarm import Agent as SwarmAgent
from uagents import Agent, Model, Bureau, Context

client = Swarm()

def transfer_to_agent_b():
    return swarm_agent_b

def transfer_to_agent_c():
    return swarm_agent_c

def helpful(context_variables):
    resp = "You are a quizzical agent. Answer their question in a riddle. Do not answer in a Haiku."
    ctx = context_variables["personality"] if context_variables["personality"] else ""
    print(ctx)
    if "friendly" in ctx:
        return f"{resp} be sure to give them lots of clues, make the riddle not too difficult to answer"
    else:
        return f"{resp}"

swarm_agent_a = SwarmAgent(
    name="Agent A",
    instructions="You are a helpful agent.",
    functions=[transfer_to_agent_b],
)

swarm_agent_b = SwarmAgent(
    name="Agent B",
    instructions="Only speak in Haikus. Find out what they want",
    functions=[transfer_to_agent_c]
)

swarm_agent_c = SwarmAgent(
    name="Agent C",
    instructions=helpful,
)

swarm_agent_d = SwarmAgent(
    name="Question generator",
    instructions="Create a random question to ask someone about any animal"
)


class Request(Model):
    text: str


class Response(Model):
    text: str


class QuestionCreation(Model):
    text: str


class QuestionCreated(Model):
    text: str


swarm_uagent = Agent(name='Swarm')
trigger_uagent = Agent(name='Trigger')
question_uagent = Agent(name='Question')


@swarm_uagent.on_message(Request)
async def handle_request(ctx: Context, sender: str, request: Request):
    response = client.run(
        agent=swarm_agent_a,
        messages=[{"role": "user", "content": request.text}],
    )

    await ctx.send(sender, Response(text=response.messages[-1]["content"]))


@trigger_uagent.on_event('startup')
async def trigger_request(ctx: Context):
    await ctx.send(swarm_uagent.address, Request(text="I want to talk to agent B."))


@trigger_uagent.on_message(Response)
async def handle_response(ctx: Context, sender: str, response: Response):
    print(f"Response from on_message : {response.text}")
    await ctx.send(question_uagent.address, QuestionCreation(text=""))


@trigger_uagent.on_message(QuestionCreated)
async def handle_response(ctx: Context, sender: str, response: Response):
    print(f"Response from on_message :", response.text)

    response = client.run(
        agent=swarm_agent_c,
        messages=[{"role": "user", "content": response.text}],
        context_variables={"user": "Jessica", "personality": "friendly, kind"}
    )

    print(response.messages[-1]["content"])


@question_uagent.on_message(QuestionCreation)
async def create_question(ctx: Context, sender: str, question: QuestionCreation):
    print("creating question...")

    response = client.run(
        agent=swarm_agent_d,
        messages=[{"role": "user", "content": "Create a random question about any animal"}],
    )

    print(response.messages[-1]["content"])

    await ctx.send(sender, QuestionCreated(text=response.messages[-1]["content"]))


bureau = Bureau()
bureau.add(swarm_uagent)
bureau.add(trigger_uagent)
bureau.add(question_uagent)
bureau.run()

```

--------------------------------

### Uagent Initialization Parameters

Source: https://uagents.fetch.ai/docs/examples/langchain

This snippet illustrates the parameters used when initializing a Uagent. It highlights the 'name', 'port', 'seed', and 'endpoint' arguments, explaining their purpose in defining the agent's identity, network communication, and API access.

```python
agent = Agent(
    name="agent",
    port=8000,
    seed="",
    endpoint=["http://127.0.0.1:8000/submit"],
)

```

--------------------------------

### Agent Mainnet Initialization Log (Python)

Source: https://uagents.fetch.ai/docs/getting-started/tokens

This snippet shows the expected log output when an agent is initialized for the mainnet. It indicates potential issues such as insufficient funds for registration on the Almanac contract and provides the wallet address for manual fund transfers.

```bash
python example.py
INFO:     [example]: Starting agent with address: agent1qftyqsedg740hfyrjpf3nlm2saf3z02sra7dn64yqqc7jktlfpg8us8us23
INFO:     [example]: Starting server on http://0.0.0.0:8001 (Press CTRL+C to quit)
INFO:     [uagents.registration]: Registration on Almanac API successful
WARNING:  [uagents.registration]: I do not have enough funds to register on Almanac contract
INFO:     [uagents.registration]: Send funds to wallet address: fetch1aatyrgyv0dcjna072fdaadsx6sennxlws3gp4w
WARNING:  [uagents.registration]: Failed to register on Almanac contract due to insufficient funds

```

--------------------------------

### Python Swarm Agent Example

Source: https://uagents.fetch.ai/docs/examples/openai/swarm

This Python code demonstrates a basic integration with Swarm, creating two agents (Agent A and Agent B) and facilitating communication between them. Agent A can call a function to transfer the conversation to Agent B. It requires the 'swarm' library.

```python
from swarm import Swarm, Agent

client = Swarm()

def transfer_to_agent_b():
    return agent_b

agent_a = Agent(
    name="Agent A",
    instructions="You are a helpful agent.",
    functions=[transfer_to_agent_b],
)

agent_b = Agent(
    name="Agent B",
    instructions="Only speak in Haikus.",
)

response = client.run(
    agent=agent_a,
    messages=[{"role": "user", "content": "I want to talk to agent B."}]
)

print(response.messages[-1]["content"])

```

--------------------------------

### Setup Wallet, Name Service, and Faucet - Python

Source: https://uagents.fetch.ai/docs/guides/name_service

Configures the necessary blockchain interaction components: a local wallet from a seed phrase, the name service contract, and a faucet for obtaining test tokens. It also defines a domain for name registration and funds the wallet. Dependencies include 'cosmpy' and 'uagents'.

```python
my_wallet = LocalWallet.from_unsafe_seed("registration test wallet")
name_service_contract = get_name_service_contract(test=True)
faucet = get_faucet()

DOMAIN = "example.agent"

faucet.get_wealth(my_wallet.address())
```

--------------------------------

### Agent Output on Startup

Source: https://uagents.fetch.ai/docs/getting-started/create

Example output logs when the 'first_agent.py' script is run. It shows registration messages, the agent's address, and the startup message.

```text
INFO:     [alice]: Registration on Almanac API successful
INFO:     [alice]: Registering on almanac contract...
INFO:     [alice]: Registering on almanac contract...complete
INFO:     [alice]: Agent inspector available at https://agentverse.ai/inspect/?uri=http%3A//127.0.0.1%3A8000&address=agent1qtu6wt5jphhmdjau0hdhc002ashzjnueqe89gvvuln8mawm3m0xrwmn9a76
INFO:     [alice]: Starting server on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO:     [alice]: Hello, I'm agent alice and my address is agent1qtu6wt5jphhmdjau0hdhc002ashzjnueqe89gvvuln8mawm3m0xrwmn9a76.

```

--------------------------------

### Create and Start React App

Source: https://uagents.fetch.ai/docs/examples/react-web

Sets up a new React project named 'finbert-news-sentiment-analysis' and starts the development server. This command initializes the frontend structure and launches the application in the browser.

```bash
npx create-react-app finbert-news-sentiment-analysis
cd finbert-news-sentiment-analysis
npm start
```

--------------------------------

### Sample requirements.txt for uAgents and LangGraph

Source: https://uagents.fetch.ai/docs/guides/langchain_agent

This file lists the necessary Python packages for running the uAgents LangGraph adapter example. It includes dependencies for uAgents, the uAgents adapter, Langchain components, LangGraph, and dotenv for environment variable management.

```text
uagents==0.22.3
uagents-adapter==0.2.1
langchain-openai==0.3.14
langchain-community==0.3.21
langgraph==0.3.31
dotenv==0.9.9

```

--------------------------------

### Run Jupyter Notebook without Poetry

Source: https://uagents.fetch.ai/docs/examples/jupyter-agent

This command starts a Jupyter notebook server using pip. It assumes Jupyter is installed in the current Python environment.

```bash
jupyter notebook
```

--------------------------------

### Complete first_agent.py Script

Source: https://uagents.fetch.ai/docs/getting-started/create

The complete Python script for the 'first_agent.py' file. It includes agent initialization, startup event handling, and the agent's run command.

```python
from uagents import Agent, Context

agent = Agent(name="alice", seed="secret_seed_phrase", port=8000, endpoint=["http://localhost:8000/submit"])

@agent.on_event("startup")
async def introduce_agent(ctx: Context):
    ctx.logger.info(f"Hello, I'm agent {agent.name} and my address is {agent.address}.")

if __name__ == "__main__":
    agent.run()

```

--------------------------------

### Define and Run a Basic Uagent

Source: https://uagents.fetch.ai/docs/examples/langchain

This snippet defines a Uagent that sends a message every two seconds to a specified recipient and logs any incoming messages. It utilizes the Agent, Context, and Model classes from the uagents library. The agent is funded if its balance is low, and its run method is called to start its execution.

```python
from uagents import Agent, Context, Model
from uagents.setup import fund_agent_if_low


class Message(Model):
    message: str


RECIPIENT_ADDRESS = "agent1qf4au6rzaauxhy2jze6v85rspgvredx9m42p0e0cukz0hv4dh2sqjuhujpp"

agent = Agent(
    name="agent",
    port=8000,
    seed="",
    endpoint=["http://127.0.0.1:8000/submit"],
)

fund_agent_if_low(agent.wallet.address())


@agent.on_interval(period=2.0)
async def send_message(ctx: Context):
    await ctx.send(RECIPIENT_ADDRESS, Message(message="hello there"))


@agent.on_message(model=Message)
async def message_handler(ctx: Context, sender: str, msg: Message):
    ctx.logger.info(f"Received message from {sender}: {msg.message}")


if __name__ == "__main__":
    agent.run()

```

--------------------------------

### Full Agent Example with GET and POST REST Endpoints

Source: https://uagents.fetch.ai/docs/guides/rest_endpoints

A complete Python script demonstrating a uAgent with custom GET and POST REST endpoints. It includes defining request and response models, setting up the agent, and implementing handlers for both types of requests. The agent listens on port 8000 and exposes routes `/rest/get` and `/rest/post`.

```python
import time
from typing import Any, Dict

from uagents import Agent, Context, Model

class Request(Model):
    text: str

class Response(Model):
    timestamp: int
    text: str
    agent_address: str

# You can also use empty models to represent empty request/response bodies
class EmptyMessage(Model):
    pass

agent = Agent(name="Rest API", seed="your_seed_phrase", port=8000, endpoint=["http://localhost:8000/submit"])

@agent.on_rest_get("/rest/get", Response)
async def handle_get(ctx: Context) -> Dict[str, Any]:
    ctx.logger.info("Received GET request")
    return {
        "timestamp": int(time.time()),
        "text": "Hello from the GET handler!",
        "agent_address": ctx.agent.address,
    }

@agent.on_rest_post("/rest/post", Request, Response)
async def handle_post(ctx: Context, req: Request) -> Response:
    ctx.logger.info("Received POST request")
    return Response(
        text=f"Received: {req.text}",
        agent_address=ctx.agent.address,
        timestamp=int(time.time()),
    )

if __name__ == "__main__":
    agent.run()

```

--------------------------------

### SenderAgent Expected Output

Source: https://uagents.fetch.ai/docs/quickstart

Displays the typical output from the SenderAgent script. This includes agent registration confirmation and received messages from other agents, indicating successful communication.

```text
agent1qdw67s95esk0zwn8qxf0ln22e8zah9rqfrqqa4qyda7mjtpf3hsw640wuwr
INFO:     [SenderAgent]: Registering on almanac contract...
INFO:     [SenderAgent]: Registering on almanac contract...complete
INFO:     [SenderAgent]: Received message from agent1qd8ymq4najh5wycvhvhcw3l5lmkgkvkrqevrs6wpp5ll0khfdq6v2cq6859: Cool! Let's get started!
INFO:     [SenderAgent]: Received message from agent1qd8ymq4najh5wycvhvhcw3l5lmkgkvkrqevrs6wpp5ll0khfdq6v2cq6859: Cool! Let's get started!
INFO:     [SenderAgent]: Received message from agent1qd8ymq4najh5wycvhvhcw3l5lmkgkvkrqevrs6wpp5ll0khfdq6v2cq6859: Cool! Let's get started!
```

--------------------------------

### Running the Uagents Fetch AI Example Script

Source: https://uagents.fetch.ai/docs/guides/search

Steps to execute the Python script for the Uagents Fetch AI example. This involves saving the script and running it from the command line, then providing input when prompted.

```bash
python search_agents.py

```

--------------------------------

### Run SenderAgent Script

Source: https://uagents.fetch.ai/docs/quickstart

Executes the SenderAgent.py script in a terminal. This script is responsible for sending messages and registering on the almanac contract. It expects to receive messages from other agents.

```python
python SenderAgent.py
```

--------------------------------

### Main Function for Agent Execution and Registration

Source: https://uagents.fetch.ai/docs/guides/chat_protocol

The main execution block where agents include their protocols, publish their manifests, and the Bureau is run to start agent communication.

```python
if __name__ == '__main__':
    initiator_agent.include(initiator_protocol, publish_manifest=True)
    responder_agent.include(responder_protocol, publish_manifest=True)
    bureau.run()
```

--------------------------------

### Run the Agent Script

Source: https://uagents.fetch.ai/docs/getting-started/create

Command to execute the 'first_agent.py' script from the terminal. This starts the agent and its associated server.

```bash
python first_agent.py
```

--------------------------------

### Streamlit App Entrypoint and Setup

Source: https://uagents.fetch.ai/docs/examples/anthropic

This Python script serves as the main entrypoint for the Streamlit application. It handles UI setup, session state management, and integrates with external libraries like httpx, requests, and Anthropic for agent communication and API interactions. It defines data models for requests and responses and includes utility functions for rendering messages and handling API keys.

```python
"""
Entrypoint for streamlit, see https://docs.streamlit.io/
"""

import asyncio
import base64
import os
import subprocess
import traceback
from datetime import datetime, timedelta
from enum import StrEnum
from functools import partial
from pathlib import PosixPath
from typing import cast
from uagents import Model
import requests

from uagents import Agent, Context, Model

import httpx
import streamlit as st
from anthropic import RateLimitError
from anthropic.types.beta import (
    BetaContentBlockParam,
    BetaTextBlockParam,
)
from streamlit.delta_generator import DeltaGenerator

from computer_use_demo.loop import (
    PROVIDER_TO_DEFAULT_MODEL_NAME,
    APIProvider,
    sampling_loop,
)
from computer_use_demo.tools import ToolResult
import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)

CONFIG_DIR = PosixPath("~/.anthropic").expanduser()
API_KEY_FILE = CONFIG_DIR / "api_key"
STREAMLIT_STYLE = """
<style>
    /* Hide chat input while agent loop is running */
    .stApp[data-teststate=running] .stChatInput textarea,
    .stApp[data-test-script-state=running] .stChatInput textarea {
        display: none;
    }
     /* Hide the streamlit deploy button */
    .stAppDeployButton {
        visibility: hidden;
    }
</style>
"""

WARNING_TEXT = "⚠️ Security Alert: Never provide access to sensitive accounts or data, as malicious web content can hijack Claude's behavior"

class Sender(StrEnum):
    USER = "user"
    BOT = "assistant"
    TOOL = "tool"

class Request(Model):
    text: str

class Response(Model):
    text: str

def setup_state():
    if "messages" not in st.session_state:
        st.session_state.messages = []
    if "api_key" not in st.session_state:
        # Try to load API key from file first, then environment
        st.session_state.api_key = load_from_storage("api_key") or os.getenv(
            "ANTHROPIC_API_KEY", ""
        )
    if "provider" not in st.session_state:
        st.session_state.provider = (
            os.getenv("API_PROVIDER", "anthropic") or APIProvider.ANTHROPIC
        )
    if "provider_radio" not in st.session_state:
        st.session_state.provider_radio = st.session_state.provider
    if "model" not in st.session_state:
        _reset_model()
    if "auth_validated" not in st.session_state:
        st.session_state.auth_validated = False
    if "responses" not in st.session_state:
        st.session_state.responses = {}
    if "tools" not in st.session_state:
        st.session_state.tools = {}
    if "only_n_most_recent_images" not in st.session_state:
        st.session_state.only_n_most_recent_images = 10
    if "custom_system_prompt" not in st.session_state:
        st.session_state.custom_system_prompt = load_from_storage("system_prompt") or ""
    if "hide_images" not in st.session_state:
        st.session_state.hide_images = False

def _reset_model():
    st.session_state.model = PROVIDER_TO_DEFAULT_MODEL_NAME[
        cast(APIProvider, st.session_state.provider)
    ]

async def initializing_messages(st, new_message):
    chat, http_logs = st.tabs(["Chat", "HTTP Exchange Logs"])
    # Render past chats
    with chat:
        for message in st.session_state.messages:
            if isinstance(message["content"], str):
                _render_message(message["role"], message["content"])
            elif isinstance(message["content"], list):
                for block in message["content"]:
                    # The tool result we send back to the Anthropic API isn't sufficient to render all details,
                    # so we store the tool use responses
                    if isinstance(block, dict) and block["type"] == "tool_result":
                        _render_message(
                            Sender.TOOL, st.session_state.tools[block["tool_use_id"]]
                        )
                    else:
                        _render_message(
                            message["role"],
                            cast(BetaContentBlockParam | ToolResult, block),
                        )

        # Render past HTTP exchanges
        for identity, (request, response) in st.session_state.responses.items():
            _render_api_response(request, response, identity, http_logs)

        # Process new message
        if new_message:
            st.session_state.messages.append(
                {
                    "role": Sender.USER,
                    "content": [BetaTextBlockParam(type="text", text=new_message)],
                }
            )
            data = {"text": new_message}

            logging.info(f"new_message {new_message}")
            response = requests.post("http://localhost:8000/rendering_messages", json=data)

```

--------------------------------

### Agent Response with Context Variables in Python

Source: https://uagents.fetch.ai/docs/examples/openai/swarm

Illustrates how to run an agent ('swarm_agent_c') with specific user messages and context variables. This function is triggered by a 'QuestionCreated' message and prints the agent's response.

```python
@trigger_uagent.on_message(QuestionCreated)
async def handle_response(ctx: Context, sender: str, response: Response):
    print(f"Response from on_message :", response.text)

    response = client.run(
        agent=swarm_agent_c,
        messages=[{"role": "user", "content": response.text}],
        context_variables={"user": "Jessica", "personality": "friendly, kind"}
    )

    print(response.messages[-1]["content"])
```

--------------------------------

### Context Variable Helper Function in Python

Source: https://uagents.fetch.ai/docs/examples/openai/swarm

A Python function `helpful` that generates agent instructions based on provided context variables. It checks for 'friendly' in the 'personality' context variable to tailor the response.

```python
def helpful(context_variables):
    resp = "You are a quizzical agent. Answer their question in a riddle. Do not answer in a Haiku."
    ctx = context_variables["personality"] if context_variables["personality"] else ""
    print(ctx)
    if "friendly" in ctx:
        return f"{resp} be sure to give them lots of clues, make the riddle not too difficult to answer"
    else:
        return f"{resp}"
```

--------------------------------

### Example Output: Agent Interactions and DB Operations

Source: https://uagents.fetch.ai/docs/examples/postgres

This is an example output demonstrating successful database connections, agent initialization, and data operations. It shows messages from the 'db_fetcher' and 'db_inserter' agents, including successful data insertion and retrieval, as well as the server startup message. This output serves as a reference for expected behavior during application execution.

```text
poetry_app | Connection successful
poetry_app | INFO:     [db_fetcher]: Hello, I'm agent db_inserter and my address is agent1qwg0h3gx2kvqmwadlg0j4r258r7amcfskx2mudz92ztjmtfdclygxrh5esu. PostgreSQL database version: PostgreSQL 16.3 (Debian 16.3-1.pgdg120+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit
poetry_app | INFO:     [db_inserter]: Received request from agent1qv470qn3vfgn3dwe5z90m8u6qvtn6chrgm4urfzdg2v9qyagln6sgnh4wwg {'employees_data': {'EmployeeID': '0', 'FirstName': 'john', 'LastName': 'wick', 'BirthDate': '29-08-1999', 'Salary': 50000}}
poetry_app | Connection successful
poetry_app | INFO:     [db_inserter]: Inserted employee data: {'EmployeeID': '0', 'FirstName': 'john', 'LastName': 'wick', 'BirthDate': '29-08-1999', 'Salary': 50000}
poetry_app | Connection successful
poetry_app | INFO:     [db_fetcher]: Retrieved all employee data: [{'EmployeeID': 0, 'FirstName': 'john', 'LastName': 'wick', 'BirthDate': '29-08-1999', 'Salary': Decimal('50000.00')}]
poetry_app | INFO:     [bureau]: Starting server on http://0.0.0.0:8000 (Press CTRL+C to quit)

```

--------------------------------

### Create and Initialize Agent, Query Fetch.ai Mainnet Address and Balance (Python)

Source: https://uagents.fetch.ai/docs/getting-started/tokens

This script initializes a uagents Agent, connects to the Fetch.ai Mainnet using cosmpy, and logs the agent's wallet address and token balance. Ensure you update the 'seed' value and store it securely. The script requires 'uagents' and 'cosmpy' libraries.

```python
from uagents import Agent, Context
import cosmpy

from cosmpy.aerial.client import LedgerClient, NetworkConfig

agent = Agent(name="alice", seed="", port=8000, test=False,  endpoint=["http://localhost:8000/submit"])

@agent.on_event("startup")
async def introduce_agent(ctx: Context):
    ctx.logger.info(f"ASI network address:{agent.wallet.address()}")
    ledger_client = LedgerClient(NetworkConfig.fetch_mainnet())
    address: str = agent.wallet.address()
    balances = ledger_client.query_bank_all_balances(address)
    ctx.logger.info(f"Balance of addr: {balances}")

if __name__ == "__main__":
    agent.run()

```
Tokens:
Raw