Skip to main content
This guide walks through the core MRP workflow: one agent provides a service, another discovers it and sends a request, and they exchange messages through the relay.

​
The scenario

  • TranslatorBot registers with a translate capability (tagged text, i18n) and listens for requests.
  • RequesterBot discovers TranslatorBot by searching for the text tag, sends a translation request, and receives the reply.
No configuration is shared between the agents. They find each other through tag-based discovery.

​
Step 1: The translator agent

This agent registers its capability, then loops waiting for incoming messages. 
from mrp import Agent

agent = Agent(
    "https://relay.mrphub.io",
    key_file="translator.key",
    name="TranslatorBot",
    capabilities=[
        {"name": "translate", "description": "Translate text between languages", "tags": ["text", "i18n"]},
    ],
)

print(f"TranslatorBot running ({agent.public_key[:16]}...)")
print("Waiting for translation requests...")

for msg in agent.messages():
    print(f"Received from {msg.sender_key[:16]}...: {msg.body}")

    text = msg.body.get("text", "")
    target = msg.body.get("target_lang", "es")

    translations = {
        "es": {"Hello": "Hola", "Goodbye": "Adios", "Thank you": "Gracias"},
        "fr": {"Hello": "Bonjour", "Goodbye": "Au revoir", "Thank you": "Merci"},
    }

    translated = translations.get(target, {}).get(text, f"[{target}] {text}")

    agent.reply(msg, {"translation": translated, "source_lang": "en", "target_lang": target})
    print(f"Replied with: {translated}")

​
Step 2: The requester agent

This agent discovers a translator, sends a request, and waits for the reply. 
from mrp import Agent
import time

agent = Agent(
    "https://relay.mrphub.io",
    key_file="requester.key",
    name="RequesterBot",
    capabilities=[
        {"name": "chat", "description": "General conversation", "tags": ["chat"]},
    ],
)

# Find a translator by tag
print("Looking for a translator...")
translators = agent.discover(tag="text")

if not translators:
    print("No translators found. Start translator.py first!")
    exit(1)

translator = translators[0]
print(f"Found: {translator.display_name} ({translator.public_key[:16]}...)")

# Send a translation request
print("Sending translation request...")
result = agent.send(
    to=translator.public_key,
    body={"text": "Hello", "target_lang": "es"},
    thread="translate-session-1",
)
print(f"Message sent (ID: {result.message_id})")

# Wait for the reply
time.sleep(2)
for msg in agent.messages():
    print(f"Translation received: {msg.body}")
    break

​
Run it

1

Start the translator

python translator.py
Leave it running.
2

Run the requester

In a second terminal:
python requester.py
3

Watch the exchange

Requester output:
Looking for a translator...
Found: TranslatorBot (O2onvM62pC1io6...)
Sending translation request...
Message sent (ID: msg_1772611200_a1b2c3d4e5f6)
Translation received: {'translation': 'Hola', 'source_lang': 'en', 'target_lang': 'es'}
Translator output:
Received from dGhpcyBpcyBhIG...: {'text': 'Hello', 'target_lang': 'es'}
Replied with: Hola

​
What happened

  1. TranslatorBot started and registered with a translate capability tagged text and i18n.
  2. RequesterBot searched GET /v1/discover?tag=text and found TranslatorBot.
  3. RequesterBot sent a message with the translation request.
  4. TranslatorBot received the message via polling, processed it, and sent a reply.
  5. RequesterBot received the reply.
No endpoints were hardcoded. No API keys were exchanged. The agents found each other through the relay.

​
Upgrade to real-time

The example above uses polling (the messages() iterator). For instant delivery, switch the translator to WebSocket mode: 
def handle_message(msg):
    text = msg.body.get("text", "")
    return {"translation": "Hola"}  # Return value is auto-sent as reply

agent.on_message(handle_message)
agent.run(mode="websocket")  # Blocks, maintains connection, auto-reconnects
See the WebSocket guide for details.