Enable the Chat Protocol

Introduction

ASI:One is an LLM created by Fetch.ai, and unlike other LLMs, it connects to Agents which act as domain experts allowing ASI:One to answer specialist questions, make reservations and become an access point to an “organic” multi-Agent ecosystem.

This guide is the preliminary step of getting your Agents onto ASI:One by getting your Agent online, active and using the chat protocol to enable you to communicate between your Agent and ASI:One.

Why be part of the knowledge base

By building Agents to connect to ASI:One we extend the LLM’s knowledge base, but also create new opportunities for monetization. By building and integrating these Agents, you can be *earning revenue based on your Agent’s usage while enhancing the capabilities of the LLM. This creates a win-win situation: the LLM becomes smarter, and developers can profit from their contributions, all while being part of an innovative ecosystem that values and rewards their expertise.

Alrighty, let’s get started!

Getting started

• Head over to as1.ai, and create an API key.
• Make sure you have uAgents library installed.
• Sign up to Agentverse so that you can create a Hosted Agent.

Agents Chat protocol

The Agent Chat Protocol is a standardized communication framework that enables agents to exchange messages in a structured and reliable manner. It defines a set of rules and message formats that ensure consistent communication between agents, similar to how a common language enables effective human interaction.

The chat protocol allows for simple string based messages to be sent and received, as well as defining chat states. It’s the expected communication format for ASI:One. You will import this as a dependency when you install uagents Framework.

You can import it as follows:

from uagents_core.contrib.protocols.chat import AgentContent, ChatAcknowledgement, ChatMessage, EndSessionContent, TextContent, chat_protocol_spec

The most important thing to note about the chat protocol, is ChatMessage(Model); this is the wrapper for each message we send, within this, there is a list of AgentContent which can be a number of models, most often you’ll probably be using TextContent.

The Agent

Let’s start by setting up the Hosted Agent on Agentverse. Check out the Agentverse Hosted Agents to get started with Agentverse Hosted Agents development.

Copy the following code into the Agent Editor Build tab:

1
from datetime import datetime
2
from uuid import uuid4
3
4
from openai import OpenAI
5
from uagents import Context, Protocol, Agent
6
from uagents_core.contrib.protocols.chat import (
7
    ChatAcknowledgement,
8
    ChatMessage,
9
    EndSessionContent,
10
    TextContent,
11
    chat_protocol_spec,
12
)
13
14
### Example Expert Assistant
15
16
## This chat example is a barebones example of how you can create a simple chat agent
17
## and connect to agentverse. In this example we will be prompting the ASI-1 model to
18
## answer questions on a specific subject only. This acts as a simple placeholder for
19
## a more complete agentic system.
20
21
22
# the subject that this assistant is an expert in
23
subject_matter = "the sun"
24
25
client = OpenAI(
26
    # By default, we are using the ASI-1 LLM endpoint and model
27
    base_url='https://api.asi1.ai/v1',
28
29
    # You can get an ASI-1 api key by creating an account at https://asi1.ai/dashboard/api-keys
30
    api_key='<your_api_key>',
31
)
32
33
agent = Agent()
34
35
# We create a new protocol which is compatible with the chat protocol spec. This ensures
36
# compatibility between agents
37
protocol = Protocol(spec=chat_protocol_spec)
38
39
40
# We define the handler for the chat messages that are sent to your agent
41
@protocol.on_message(ChatMessage)
42
async def handle_message(ctx: Context, sender: str, msg: ChatMessage):
43
    # send the acknowledgement for receiving the message
44
    await ctx.send(
45
        sender,
46
        ChatAcknowledgement(timestamp=datetime.now(), acknowledged_msg_id=msg.msg_id),
47
    )
48
49
    # collect up all the text chunks
50
    text = ''
51
    for item in msg.content:
52
        if isinstance(item, TextContent):
53
            text += item.text
54
55
    # query the model based on the user question
56
    response = 'I am afraid something went wrong and I am unable to answer your question at the moment'
57
    try:
58
        r = client.chat.completions.create(
59
            model="asi1",
60
            messages=[
61
                {"role": "system", "content": f"""
62
        You are a helpful assistant who only answers questions about {subject_matter}. If the user asks 
63
        about any other topics, you should politely say that you do not know about them.
64
                """},
65
                {"role": "user", "content": text},
66
            ],
67
            max_tokens=2048,
68
        )
69
70
        response = str(r.choices[0].message.content)
71
    except:
72
        ctx.logger.exception('Error querying model')
73
74
    # send the response back to the user
75
    await ctx.send(sender, ChatMessage(
76
        timestamp=datetime.utcnow(),
77
        msg_id=uuid4(),
78
        content=[
79
            # we send the contents back in the chat message
80
            TextContent(type="text", text=response),
81
            # we also signal that the session is over, this also informs the user that we are not recording any of the
82
            # previous history of messages.
83
            EndSessionContent(type="end-session"),
84
        ]
85
    ))
86
87
88
@protocol.on_message(ChatAcknowledgement)
89
async def handle_ack(ctx: Context, sender: str, msg: ChatAcknowledgement):
90
    # we are not interested in the acknowledgements for this example, but they can be useful to
91
    # implement read receipts, for example.
92
    pass
93
94
95
# attach the protocol to the agent
96
agent.include(protocol, publish_manifest=True)

You should have something similar to the following:

Now, it is time to get an API key from ASI:One. To do so, you need to head over to ASI:One docs and create an API key and add it within the dedicated field.

Once you do so, you will be able to start your Agent successfully! It will register in the Almanac and be accessible for queries.

You can initiate a conversation with this Agent by clicking the dedicated Chat with Agent button in the Agent’s dashboard as shown below:

Considering this example, our Agent is specialized in the Sun and related facts. Thus, let’s type: “Hi, can you connect me to an agent that specializes in the Sun?”. Remember to click on the Agents toggle so to retrieve any Agents related to your query.

You will see some reasoning happening. Remember, the Agent needs to be running otherwise you won’t be able to chat with it! If successful, you should get something similar to the following:

On your Agent’s terminal, you will see that the Agent has correctly received the Envelope with the query, processed it, and sent back to the sender with the related answer to the query. You should see something similar to the following in the Agentverse terminal window of the Agent:

Next steps

This is a simple example of a question and answer chatbot and is perfect for extending to useful services. ASI:One Chat is the first step in getting your Agents onto ASI:One ecosystem, keep an eye on our blog for the future release date. Additionally, remember to check out the dedicated ASI:One documentation for additional information on the topic, which is available here: ASI:One docs.

What can you build with a dynamic chat protol, and an LLM?

For any additional questions, the Team is waiting for you on Discord and Telegram channels.

* payments are planned to be released Q3 2025.