Multi-Agent Systems

Multi-Agent Systems
Mehdi Dastani
What is JADE?

JADE (Java Agent DEvelopment framework) is a FIPA compliant
agent platform and a Java framework for the development of MAS.

The Jade platform is based on a middleware that facilitates the
development of distributed multi-agent applications based on a peerto-peer communication architecture.

The environment can evolve dynamically with agents that appear
and disappear in the system according to the needs and the
requirements of the context.

JADE Project started in July 1998 as joint development of Telecom
Italia Lab and Parma University. JADE is the Leading Open Source
FIPA compliant agent platform.

Currently JADE development is driven by a board composed of five
industrial partners:TILAB, Motorola, Whitestein Technologies AG,
Profactor GmbH, and France Telecom R&D.
JADE

An agent platform that implements the basic services and infrastructure
of a distributed multi-agent application:
agent life-cycle, agent mobility, and agent security
white & yellow-page services
peer-to-peer message transport & parsing; also multi-party
communication
scheduling of multiple agent tasks
set of graphical tools to support monitoring, logging, and debugging

Some relevant features:

Distributed Agent Platform

seen as a whole from the outside world
spanning multiple machines
enables interoperability through FIPA compliance

Two levels concurrency model

Inter-agent (pre-emptive, Java threads)
Intra-agent (co-operative, Behaviour classes)
The architectural model

A JADE-based application is composed of a collection of active components
called Agents. Each agent has a unique name.

Each agent is a peer since he can communicate in a bidirectional way with all
other agents

Each agent lives in a container (that provides its run time) and can migrate
within the platform

One container plays the role of main (where AMS, DF live)
Agent class and names

A type of agent is created by extending the jade.core.Agent class
and redefining the setup() method.

Each Agent instance is identified by an AID (jade.core.AID),
composed of a unique name plus some addresses; the getAID()
method of the Agent class

Agent names are of the form <local-name>@<platform-name>.
The complete name of an agent must be globally unique. The
default platform name is <main-host>:<main-port>/JADE. The
platform name can be set using the –name option

Within a single JADE platform agents are referred through their
names only.

Given the name of an agent its AID can be created as
AID id = new AID(localname, AID.ISLOCALNAME);
AID id = new AID(name, AID.ISGUID);
Hello World: A Simple Example
import jade.core.Agent;
public class HelloAgent extends Agent
{
protected void setup()
{
System.out.println("Hello World. ");
System.out.println("My name is "+ getLocalName());
}
}
$> javac HelloAgent.java
$> java jade.Boot fred:HelloAgent
This is JADE 3.0b1 ….
Hello World.
My name is fred
Starting Agent Execution

Birth of a new agent

The agent is given an identifier
It is registered with the AMS
It is put in the AP_ACTIVE state
Its setup() method is executed
The setup() method is therefore the point where any

application-defined agent activity starts
Initialise the agent
Add tasks using the method addBehaviour()

Scheduled as soon as the setup() method ends
The Behaviour class

The actual job that an agent does is typically carried out within
“behaviours”
Behaviours are created by extending jade.core.behaviours.Behaviour
class
To make an agent execute a task it is sufficient to create an instance of
the corresponding Behaviour subclass and call the addBehaviour()
method of the Agent class.
Each Behaviour subclass must implement

public void action(): what the behaviour actually does
public boolean done(): Whether the behaviour is finished
An agent can execute several behaviours in parallel, however,
behaviour scheduling is not preemptive, but cooperative and
everything occurs within a single Java Thread
Behaviour switch occurs only when the action() method of the currently
scheduled behaviour returns.
Hello World: A Simple Example
import jade.core.Agent;
import jade.core.behaviours.*;
public class myAgent extends Agent {
protected void setup() { addBehaviour( new myBehaviour( this ) ); }
class myBehaviour extends SimpleBehaviour {
public void action() { //... the real programming !! }
private boolean finished = false;
public boolean done() { return finished; }
} // ----------- End myBehaviour
} //end class myAgent
Hello World! My name is fred
Hello World! My name is fred
Hello World! My name is fred
Hello World! My name is fred ..... loops until stopped with CTL-C.... !
Hello World: A Simple Example
import jade.core.Agent;
import jade.core.behaviours.*;
public class myAgent extends Agent {
protected void setup() { addBehaviour( new myBehaviour( this ) ); }
class myBehaviour extends SimpleBehaviour {
…
int n=0;
public void action() { …; n++; }
public boolean done() { return n>=3; }
} // ----------- End myBehaviour
} //end class myAgent
Hello World! My name is fred
Hello World! My name is fred
Hello World! My name is fred
Behaviour types

“One shot” behaviours.
“Cyclic” behaviours.
“Complex” behaviours.
WakerBehaviour
The action() and done() method are already implemented so that
the handleElapsedTimeout() method (to be implemented by
subclasses) is executed after a given timeout
After that execution the behaviour completes.
TickerBehaviour
The action() and done() method are already implemented so that
the onTick() (to be implemented by subclasses) method is
executed periodically with a given period
The behaviour runs forever unless its stop() method is executed
WakerBehaviour: A Simple Example
public class MyAgent extends Agent {
protected void setup() {
System.out.println(“Adding waker behaviour”);
addBehaviour(new WakerBehaviour(this, 10000) {
protected void handleElapsedTimeout() {
// perform operation X
}
} );
}
}
Operation X is performed 10 seconds after the “Adding waker behaviour”
printout appears.
TickerBehaviour: A Simple Example
public class tickeragent extends Agent {
Behaviour loop;
protected void setup() {
loop = new TickerBehaviour( this, 10000 ) {
protected void onTick() {
// perform operation X
}
};
addBehaviour( loop );
}
}
Operation X is performed periodically every 10 seconds.
Stopping Agent Execution

Any behaviour can call the Agent.doDelete() method
in order to stop agent execution.

The Agent.takeDown() method is executed when the agent
is going to be destroyed

The agent is still registered with the AMS and can therefore
send messages to other agents
The takeDown() method can be overridden to implement any
necessary cleanup.
Just after the takeDown() method is completed, the
agent will be de-registered and its thread destroyed
More about behaviours

The onStart() method of the Behaviour class is
invoked only once before the first execution of the
action() method.

The onEnd() method of the Behaviour class is invoked
only once after the done() method returns true.

The removeBehaviour() method of the Agent class can
be used to remove a behaviour from the agent pool of
behaviours. The onEnd() method is not called.

When the pool of active behaviours of an agent is
empty, the agent enters the IDLE state and its thread
goes to sleep
ACLMessage

Based on asynchronous
message passing
Message format defined by the ACL language (FIPA)
Messages exchanged by agents are instances of the
jade.lang.acl.ACLMessage
Sending a message = creating an ACLMessage object and
calling the send() method of the Agent class
Reading messages from the private message queue is
accomplished through the receive() method
Provide accessor methods to get and set all the fields defined
by the ACL language : get/setPerformative(), get/setSender(),
add/getAllReceiver(), get/setLanguage(), get/setOntology(),
get/setContent()
Blocking or selecting

The block() method of the Behaviour class removes a behaviour
from the agent pool of behaviours and puts it in a blocked state.
Each time a message is received all blocked behaviours are
inserted back in the agent pool and have a chance to read and
process the message.

It is possible to read only messages with certain characteristics
specifying a jade.lang.acl.MessageTemplate parameter in the
receive() method.

The Agent class also provides the blockingReceive() method;
there are overloaded versions that accept a MessageTemplate
and/or a timeout.
Blocking or selecting
public void action() {
ACLMessage msg = myAgent.receive();
if (msg != null) {
// Message received. Process it
...
}
else {
block();
}
}
FIPA ACL Message Elements

performative
sender
receiver
reply-to
content
language
encoding
ontology
protocol
conversation-id
reply-with
in-reply-to
reply-by
What action the message performs
Initiator of the message
Recipient of the message
Recipient of the message reply
Content of the message
Language used to express content
Encoding used for content
Ontology context for content
Protocol message belongs to
Conversation message belongs to
Reply with this expression
Action to which this is a reply
Time to receive reply by
ACL Message Example
(request
:sender (:name [email protected]:8080)
:receiver (:name rexhotel@tcp://hotelrex.com:6600)
:ontology personal-travel-assistant
:language FIPA-SL
:protocol fipa-request
:content
(action movenpickhotel@tcp://movenpick.com:6600
(book-hotel (:arrival 25/11/2000) (:departure 05/12/2000) ...
)))

Any language can be used as a Content Language, e.g.:
KIF, Prolog, SQL, Serialized Objects, Binary Large Objects
FIPA-SL, FIPA-CCL, FIPA-RDF, FIPA-KIF
Sending/receiving Message
ACLMessage msg = receive();
ACLMessage reply = new ACLMessage( ACLMessage.INFORM );
reply.setContent( "Pong" );
reply.addReceiver( msg.getSender() );
send(reply);
public void action() {
ACLMessage msg = receive();
if (msg!=null) { ...;
ACLMessage reply = msg.createReply();
reply.setPerformative(ACLMessage.INFORM );
reply.setContent(" Pong" );
reply.send();
}
block();
}
DF (Directory Facilitator)
Interacting with the DF Agent

The DF is an agent, it communicates using ACL
The ontology and language that the DF “understands”
are specified by FIPA
The jade.domain.DFService class provides static utility
methods that facilitate the interactions with the DF

When an agent registers with the DF it must provide
a description

The agent AID
A collection of service descriptions (class
ServiceDescription):

The service type (e.g. “Weather forecast”)
The service name (e.g. “Meteo-1”)
The languages, ontologies and interaction protocols that must
be known to exploit the service
A collection of service-specific properties in the form key-value
pair
When an agent searches/subscribes to the DF it
must specify another DFAgentDescription that is
used as a template
Interacting with the DF Agent
protected void setup() {
...
DFAgentDescription dfd = new DFAgentDescription();
dfd.setName(getAID());
ServiceDescription sd = new ServiceDescription();
sd.setType(“book-selling”);
sd.setName(“JADE-book-trading”);
dfd.addServices(sd);
DFService.register(this, dfd);
...
}
protected void takeDown() {
…
DFService.deregister(this);
…
}
Agent Management System

The authority in a JADE platform; all platform
management actions (creating/killing agents,
killing containers...)
Other agents can request the AMS to perform
these actions by using

The fipa-request interaction protocol
The SL language
The JADE-Management ontology and related
actions
getAMS() => the AID of the AMS
The main graphical tools of JADE

Management, control, monitoring, and
debugging of a multi-agent platform

RMA (Remote Monitoring Agent)
Dummy Agent
Sniffer Agent
Introspector Agent
Log Manager Agent
DF (Directory Facilitator) GUI
Advantages

No need to implement the Agent Platform
AMS, DF executed at start-up
No need to implement agent-management ontology and
functionalities
An agent is registered with the Agent Platform within its
constructor, it is given a name and an address
The DFService class provides a simplified interface to access the
services of the DF (registration, searching, lease-renewal, …)
No need to implement Message Transport and Parsing
Automatically (and possibly efficiently) done by the framework
when sending/receiving messages
Interaction Protocols must only be extended via handle methods
Standard FIPA !

Download Report

Multi-Agent Systems

Paperzz.com

Your Paperzz