SPADE: Smart Python Agent Development Environment

The core logic of a SPADE agent is implemented via Behaviours. You add a behaviour to an agent using the add_behaviour() method inside the agent's setup() coroutine.

Common Behaviour Types

• spade.behaviour.CyclicBehaviour: A loop-like behaviour that repeats without a specific period.

Behaviour Lifecycle Methods

• on_start(): An async coroutine executed just before the first iteration. Use it for initialization.
• run(): An async coroutine that contains the core logic. It is called on every iteration of the behaviour loop. Because it is async, you can use await (e.g., await asyncio.sleep(1)) without blocking the event loop.
• on_end(): An async coroutine executed when a behaviour is finished or killed.

import asyncio
import spade
from spade.agent import Agent
from spade.behaviour import CyclicBehaviour

class DummyAgent(Agent):
    class MyBehav(CyclicBehaviour):
        async def on_start(self):
            print("Starting behaviour . . .")
            self.counter = 0

        async def run(self):
            print("Counter: {}".format(self.counter))
            self.counter += 1
            await asyncio.sleep(1)

        async def on_end(self):
            print("Behaviour ended")

    async def setup(self):
        b = self.MyBehav()
        self.add_behaviour(b)

async def main():
    dummy = DummyAgent("dummy@localhost", "your_password")
    await dummy.start()
    # Use wait_until_finished to keep the agent running
    from spade import wait_until_finished
    await wait_until_finished(dummy)

if __name__ == "__main__":
    spade.run(main())

The SPADE Agent Model is built on three core components that work together to enable autonomous agent communication and execution:

1. Connection Mechanism: Agents use a Jabber ID (JID) and a password to register and authenticate with an XMPP server. Once registered, the agent maintains a persistent communication stream.
2. Message Dispatcher: An internal component that acts as a mailman. It automatically handles incoming messages by placing them in the correct behaviour 'mailbox' based on message templates, and handles outgoing messages by placing them into the communication stream.
3. Behaviours: Tasks that an agent executes. An agent can run multiple behaviours simultaneously. Behaviours use message templates to filter which incoming messages they should process.

To identify an agent on the platform, you must use a JID in the format username@serverdomain (e.g., myagent@localhost).

The FSMBehaviour allows you to build complex agent logic using a Finite State Machine. It manages transitions between different State objects.

Key Concepts

• States: Subclasses of State (which is itself a OneShotBehaviour). You must override the run() coroutine. A state becomes a 'final state' if it does not call set_next_state().
• Registration: Use add_state(name, state, initial=False) to register states. An FSM can have only one initial state; if multiple are registered with initial=True, the last one registered wins.
• Transitions: Use add_transition(source, dest) to define valid paths between state names. If a state attempts to transition to a non-registered transition, a NotValidTransition exception is raised and the FSM stops.
• State Transitions: Inside a state's run() method, call self.set_next_state("STATE_NAME") using the exact string name used during registration. If the name is unknown, a NotValidState exception is raised.
• Message Queue: All states within a single FSMBehaviour share the same unique template and message queue.

from spade.behaviour import FSMBehaviour, State

STATE_A = "STATE_A"
STATE_B = "STATE_B"

class StateA(State):
    async def run(self):
        print("In State A")
        self.set_next_state(STATE_B)

class StateB(State):
    async def run(self):
        print("In State B (Final)")
        # Not calling set_next_state makes this the final state

class MyFSM(FSMBehaviour):
    pass

# In Agent setup:
fsm = MyFSM()
fsm.add_state(name=STATE_A, state=StateA(), initial=True)
fsm.add_state(name=STATE_B, state=StateB())
fsm.add_transition(source=STATE_A, dest=STATE_B)
self.add_behaviour(fsm)