Download - AI-MAS 3.12.2004
AI-MAS
3.12.2004
JADE An agent platform that implements the basic services and
infrastructure of a distributed multi-agent application: agent life-cycle and agent mobility white & yellow-page services peer-to-peer message transport & parsing; also multi-party
communication agent security scheduling of multiple agent tasks set of graphical tools to support monitoring, logging, and
debugging encourages the development of pro-active applications
Some relevant features: is extremely light-weight, ported to J2ME-CLDC-MIDP 1.0;
mobile terminals enables interoperability through FIPA compliance is an open source project originated by TILAB and currently
governed by an International Board is used by several R&D projects
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) The main-container can be replicated via replication service
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);
It is possible to pass arguments to an agent; the getArguments() method
An agent terminates when its doDelete() method is called. On termination the agent’s takeDown() method is invoked
(intended to include clean-up operations).
The Behaviour class The actual job that an agent does is typically carried out
within “behaviours” Behaviours are created by extending the
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.
Behaviour types “One shot” behaviours. “Cyclic” behaviours. “Complex” behaviours. WakerBehaviour
The action() and done() method are already implemented so that the onWake() 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
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.
Each behaviour has a pointer to the agent executing it: the protected member variable myAgent
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 and puts it in a blocked state (not a blocking call!!). 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.
To avoid this 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.
FIPA Message Structure
FIPA ACL Message Elements
p e r f o r m a t i v e What action the message performs
s e n d e r Initiator of the message r e c e i v e r Recipient of the message r e p l y - t o Recipient of the message reply c o n t e n t Content of the message l a n g u a g e Language used to express content e n c o d i n g Encoding used for content o n t o l o g y Ontology context for content p r o t o c o l Protocol message belongs to c o n v e r s a t i o n - i d Conversation message belongs to r e p l y - w i t h Reply with this expression i n - r e p l y - t o Action to which this is a reply r e p l y - b y 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
Communicative Act Library accept-proposal: accept a previously submitted proposal agree: agree to perform some action, possibly in the future cancel: cancel some previously requested action cfp: make a cal for proposals to perform a given action confirm: inform a receiver that a given proposition is true disconfirm: inform a receiver that a given proposition is false failure: inform another agent that an action was attempted but
failed inform: inform a receiver that a given proposition is true not-understood: informs a receiver that sender did not
understand query-if: ask another agent whether a given proposition is true request: requests a receiver to perform some action
Communicative Act Library propose: submit a proposal to perform a certain action query-ref: ask another agent for the object referred to by a
referential expression refuse: refuse to perform a given action reject-proposal: reject a proposal during a negotiation request-when: request a receiver to perform some action when
some given proposition becomes true request-whenever: request a receiver to perform some action
as soon as some proposition is true and thereafter each time the proposition becomes true again
subscribe: a persistent intention to notify the sender of a value, and to notify again whenever the value changes
propagate: the receiver treats the embedded message as sent directly to it, and must identify the agents denoted by the given descriptor and send the received propagate message to them
proxy: the receiver must select target agents denoted by a given description and to send an embedded message to them
Interaction protocols Jade automatically handles the
flow of messages and the timeouts
callback methods that should be redefined to take the necessary actions
jade.proto package contains behaviours for both the initiator and responder role (FIPA-Request, FIPA-Contract-Net, FIPA-Subscribe)
Other FIPA IPs : FIPA-Query, FIPA-Request-When, FIPA-AIterated-Contract-Net, FIPA-Auction-English, FIPA-Auction-Dutch, FIPA-Brokering, FIPA-Recruiting, FIPA-Propose
Predefined sequences of messages exchanged by agents during a conversation
Handling content expressions
Creating the Ontology (domain specific) Defining the schemas ontology elements Defining the corresponding Java classes
Handling content expressions as Java objects Using the ContentManager to fill and parse message
contents Ontologies can be created with Protégé (with the
beangenerator plugin)
The Content Reference Model
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 register(); modify(); deregister(); search();
The JADE DF also supports a subscription mechanism
DFDescription format
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
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
Mobility “Hard mobility”
Status: an agent can stop its execution on the local container move to a remote container (likely on a different host) restart its execution there from the exact point where it was
interrupted. Code: If the code of the moving agent is not available on the
destination container it is automatically retrieved on demand.
An agent must be Serializable in order to be able to move Mobility can be
self-initiated through doMove() of the Agent class forced by the AMS (following a request from another agent)
Agent cloning is also available - method doClone()
Security Add-on that prevents the
threats (malicious kill or shutdown, sniffing or tampering the messages) by providing support for: Authentication and
authorization End-to-end message
integrity and confidentiality
All security related API are embedded into the SecurityHelper
Signing, encryption Policy files per user:
Platform, Container, AMS, Agent, Message
ACLMessage msg = new ACLMessage(ACLMessage.INFORM);......SecurityHelper myHelper = (SecurityHelper)getHelper("jade.core.security.Security");myHelper.setUseSignature(msg);send(msg);
Advanced features Using JADE (i.e. creating a container and starting agents)
from an external Java program (servlets, applets, JSP..) Executing a normal JADE behavior in a dedicated thread Saving and reloading agent state on relational DB
(persistence based on www.hibernate.org); add-on Integration with JESS (Java Expert System Shell)
it allows reasoning about messages in JESS it allows a JESS program to control sending/receiving
messages and/or creating/destroying JADE behaviours Distributed security, fault tolerance, support for replicated
agents and services Protégé, XML, RDF and OWL Application-specific persistent delivery filters & JADE
kernel-level services The LEAP add-on
LEAP
JADE agents on PDA and mobile phones JADE-LEAP (J2SE, PJava, MIDP): different internal
implementation, same APIs for agents JADE-LEAP for MIDP is itself a MIDlet; the main class is
jade.MicroBoot A MIDlet must be packaged as a single JAR file => mix
library & app. Classes MIDP configuration parameters are specified in the
JAD/manifest of the MIDlet Minimize target (ant) + obfuscator : 450 k -> 30-150 k Logging - uniform way (jade.util.Logger class)
J2SE : JAVA Logging PJava : System.out.println() MIDP : RecordStore
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 !
Roadmap
Links
http://jade.cselt.it
http://www.fipa.org
http://www.hibernate.org
http://herzberg.ca.sandia.gov/jess/
http://protege.stanford.edu/
www.swi.psy.uva.nl/usr/aart/beangenerator
http://jadex.sourceforge.net