Rule Responder - Pragmatic Agent Web Using RuleML

Rule Responder – RuleML-based Agents for
Distributed Collaboration on the Pragmatic Web
22/23rd October 2007

Towards a Pragmatic Agent Web
Rule Responder
Reaction RuleML – Rule Interchange Format
Enterprise Service Bus – Communication Middleware
Rule Engines – Execution Environments
Rule Responder Use Cases
Summary

A. Paschke1, H. Boley, A. Kozlenkov, B. Craig
1 Bioinformatics, BIOTEC Center, Technical University Dresden

Int. Conference on the Pragmatic Web, Tilburg, Netherlands, 2007

Semantic Web Stack

Main Principles (Semantic Web Stack 2003)
Development in layers
Downwards compatible
Upwards: Partial understanding
2 2nd International Conference on the Pragmatic Web Rule Responder © Adrian Paschke 2007

The Future of the Semantic Web?

T. Berners-Lee. Web for real people, I., Horrocks: Semantic web architecture : Stack or two towers?,
http://www.w3.org/2005/talks/0511-keynote-tbl, 2005. Dagstuhl Castle ,Germany, 2005.

Semantic Web addresses syntax and semantics of representation languages for
meta data vocabularies and semantic domain descriptions

An explicit pragmatic layer addressing use of semantic resources within a
pragmatic context is missing

Towards a Pragmatic Web

1. Explicit Meta-data
vCard, PICS, Dublin Core,
RDF, IEEE LOM (Learning
Objects Metadata), Micro
Formats, FOAF, SIOC …

2. Ontologies
RDFS, OWL Lite|DL|Full

3. Logic and Inference
e.g. Logic Programming
Rule/Inference Engines

4. Software Agents and
Web Services
FIPA, Semantic Web
Services, RBSLA, …


Pragmatic Agent Web - Example with Two Kinds of
Collaborative Agents

Interaction


Pragmatic Web
Semiotics, the study of sign processes, includes the study of how meaning is
constructed and understood.

„Pragmatics, a basic field of linguistics today, originally had its roots in Morris's
idea of a division of signs concerned with quot;the relations of signs to their
interpretersquot; or users. “
Eugen Halton, http://www.nd.edu/~ehalton/Morrisbio.htm, 1992

Pragmatic Web
Utilize the heterogenous Semantic Web resources, meta data and meaning
representations with intelligent agents and web-based services with the
ability to understand the others intended meaning (pragmatic
competence)
Collaborate in a communicative conversation-based process where
content and context is interchanged in terms of messages (relation of signs)
between senders and receivers (interpreters/users).
Pragmatic layer/wrapper around semantic/content e.g. by KQML / ACL like
speech-act primitives (e.g. assert(content), retract(content), query(kb))
Model, negotiate and control shared and invividual meanings
requires learning and knowledge adaption / updates

Pragmatic
Agent Web

Rule Responder Project:
http://www. responder.ruleml.org/


Benefits of Rule-Based Decision and
Reaction Logic
1. Compact declarative representation of rules
Clear semantics
Global rules which might apply in several contexts (reusability)
Separation of contract rules from the application code
Extensibility of the rule base (without changing the interpreter)

2. Efficient, generic interpreters (rule engines) for automated
rule chaining and execution of reaction rules

3. Automated conflict detection of rule conflicts
Traceable and verifiable results
Integrity constraints are possible
Automated conflict resolution by rule prioritization

Rules play an important role to automatically and contextually
transform data, derive new conclusions and decisions from existing
knowledge and behaviourally act according to changed conditions or
occurred events

Rule Responder Architecture
1. Computational independent model (CIM) with rules,
processes, conversational flows (e.g. in a natural or visual
language)

2. Platform independent model (PIM) which represents the
rules, events and ontologies in a common (standardized)
interchange format (e.g. a markup language)

3. Platform specific model (PSM) which encodes the rule
statements in the language of a specific execution
environment (e.g. a rule engine / inference service or
compiled code)


RuleML / Reaction RuleML
Platform Independent
Rule Interchange Format

http://ruleML.org
http://ibis.in.tum.de/research/ReactionRuleML/


RuleML as Common Rule Interchange Format
Rule Markup and Modeling Initiative (RuleML) (www.ruleml.org)
Standardization effort for a rule markup and modelling language, tools and
applications

RuleML is the de facto open language standard for rule interchange/
rule markup on the Web

Reaction RuleML (http://ibis.in.tum.de/research/ReactionRuleML/)
Language family for reaction rules and complex event messaging / processing

RuleML

Derivation Reaction Integrity Transformation
Rules Rules Constraints Rules

RuleML
Translators
Homogeneous Approach
Reaction RuleML
Integrity
RuleML
Derivation RuleML

RuleML Enables ...

modelling
markup UML
translation RDF
Rule interchange in XML
execution ASCII
publication
archiving

RuleML Language Family – Derivation RuleML


Schema Modularization
XML Schema + EBNF Syntax
Full RDF compatibility via
type and role tags (akin to
triple syntax);
XML Schema Modularization:
Layered and uniform design
The layers are organized around
increasing expressiveness levels
Benefits:
- easier to learn the language and to
understand their relationships
- facilitates reusability and complex
language assemblies from modules
- provides certain guidance to vendors
who might be interested only in a
particular subset of the features
- easier to maintain, manage and
extend in a distributed environment


RuleML as Rule Interchange Format

''The discount for a customer buying a product is 5.0 percent if
the customer is premium and the product is regular.''
<Implies>
Implies
<head>
head
<Atom>
Atom
<op><Rel>discount</Rel></op>
op Rel discount
<Var>customer</Var>
Var customer
<Var>product</Var>
Var product
<Ind>5.0 percent</Ind>
5.0 percent
Ind
</Atom>
</head>
<body>
body
<And>
And
<Atom>
Atom
<op><Rel>premium</Rel></op>
op Rel premium
<Var>customer</Var>
Var customer
</Atom>
<Atom>
Atom
<op><Rel>regular</Rel></op>
opr Rel regular
<Var>product</Var>
Var product
</Atom>
</And>
</body>
</Implies>

Scope of Reaction RuleML


Reaction RuleML is intended for …
Enable interoperation between various domains of reaction rules,
event/action definition and processing such as:
Event Processing Networks
Complex Event Processing (CPE)
Event Driven Architectures (EDAs)
Reactive, rule-based Service-Oriented Architectures (SOAs)
Active Semantic Web Applications
Real-Time Enterprise (RTE)
Business Activity Management (BAM)
Business Performance Management (BPM)
Service Level Management (SLM) with active monitoring and
enforcing of Service Level Agreements (SLAs) or e-Contracts
Supply Chain Event Management
Policies
…

General Concepts

General (reaction) rule form that can be
specialized as needed
Three general execution styles:
Active: 'actively' polls/detects occurred events in global ECA style,
e.g. by a ping on a service/system or a query on an internal or
external event database
Messaging: Waits for incoming complex event message
Reasoning: KR event/action logic reasoning and transitions (as e.g.
in Event Calculus, Situation Calculus, TAL formalizations)

Appearance
Global: ‘globally’ defined reaction rule
Local: ‘locally’ defined (inline) reaction rule nested in an outer rule


General Syntax for Reaction Rules (Reaction RuleML 0.2)

<Rule style=quot;activequot; evaluation=quot;strongquot;>
<label>  </label>
<scope>  </scope>
<qualification>  </qualification>
<oid>  </oid>

<on>  </on>
<if>  </if>
<then>  </then>
<do>  </do>
<after>  </after>
<else>  </else>
<elseDo>  </elseDo>
<elseAfter>  </elseAfter>
</Rule>

Messages in Reaction RuleML
<Message mode=quot;outboundquot; directive=quot;ACL:informquot;>
<oid>  </oid>
<protocol>  </protocol>
<sender>  </sender>
<content>  </content>
</Message>

@mode = inbound|outbound – attribute defining the type of a message
@directive – attribute defining the pragmatic context of the message, e.g. one
or more FIPA ACL performatives, KQML, OWL-QL, Standard Deontic Logic
norms, …
< oid > – the conversation id used to distinguish multiple conversations and
conversation states
< protocol > – a transport protocol such as HTTP, JMS, SOAP, Jade,
Enterprise Service Bus (ESB) ...
< sender >< receiver > – the sender/receiver agent/service of the message
< content > – message payload transporting a RuleML / Reaction RuleML
query, answer or rule base

Complex Event Processing (1)

Event Definition
Definition of event pattern by event algebra

Event Selection
Defines selection function to select one event from several occurred events (stored in
an event instance sequence) of a particular type, e.g. “first”, “last”
Crucial for the outcome of a reaction rule, since the events may contain different
(context) information, e.g. different message payloads or sensing information

Event Consumption
Defines which events are consumed after the detection of a complex event
An event may contribute to the detection of several complex events, if it is not
consumed
Distinction in event messaging between “multiple receive” and “single receive”
Events which can no longer contribute, e.g. are outdated, should be removed

Separation of this phases is crucial for the outcome of a reaction rule
base in the context of complex events
Declarative configuration of different selection and consumption
policies


Example: Request / Query
...
<Message mode=quot;outboundquot; directive=quot;ACL:query-refquot;>
<oid> <Ind>RuleML-2007</Ind> </oid>
<protocol> <Ind>esb</Ind> </protocol>
<sender> <Ind>User</Ind> </sender> FIPA ACL directive
<content>
<Atom>
<Rel>getContact</Rel>
<Ind>Website</Ind>
<Var>Contact</Var>
</Atom>
</content>
</Message>
...

Message is local to the conversation state (oid) and
pragmatic context (directive)

Example: Response / Answer
<Message …>
...
<content>
<Atom>
<Rel>getContact</Rel>
<Ind>Website</Ind>
<Expr>
<Fun>person</Fun>
<Ind>Adrian</Ind>
<Ind>Program Co-Chair RuleML-2007</Ind>
<Ind>Technical University Munich</Ind>
<Ind>paschke@in.tum.de</Ind>
<Ind>+49 89 289 17504</Ind>
</Expr>
</Atom>
</content>
...
</Message>

Enterprise Service Bus
Communication Middleware
+
Service Object Broker


Mule Enterprise Service Bus

Mule ESB Open Source
Message Platform and
distributed Object Broker
Staged Event Driven
Architecture (SEDA)
> 30 Protocols (JMS, HTTP,
SOAP …)
Synchronous and
Asynchronous
Communication
Complex Message-driven
Event Processing (CEP)


Mule Enterprise Service Bus


Platform Specific Execution
Environments

Rule Engines / Inference Services


Prova – A Semantic Web Rule Engine
Open-Source Project hosted at Sourceforge (http://www.prova.ws/)

Distributed Semantic Web Rule Engine and Agent/Service Oriented
Architecture written in Java focusing among other application domains on
bioinformatics applications
Principles: Separation of logic (declarative), data access (procedural
attachments and query languages), and computation (inference and
external procedural computation)
Combines the benefits of declarative (rule-based), Semantic Web meta
data and ontology, procedural/object oriented (e.g., Java), and workflow
languages (e.g., BPEL)
Standard ISO Prolog scripting syntax + extended logic programming
semantics + tight integration of Java and “webized” Semantic Web
languages as type systems (vocabularies)
“Distributed Modular Meta-Data Annotated Labeled Order-Sorted Typed
Extended Logic Programs”

Prova – Selected Expressive Features

External Data and Object Integration + Query Built-Ins
Java Integration
XML Integration
SQL Integration
RDF Integration
External Type Systems: Order-Sorted Polymorphic Typed Logic
Java Class Hierarchies
Semantic Web Ontologies
Input/Output Mode Declarations
Module Import and Integration: Order Modularized Logic Programs
Meta Data Labels and Scopes (constructive views)
Integrity Constraints and Test Cases for Verification and Validation
Backward-reasoning Derivation rules + ECA-style rules
Messaging Reaction Rules
Dynamic Transactional Updates


Prova Agent Architecture

Prova-AA offers
message-oriented context-dependend reaction rules;
message sending and receiving for local and remote communication actions;
uniform handling of communication protocols (JMS, JADE, plus any of the
more than 30 protocol supported by the Enterprise Service Bus).
message payload as complex terms containing typed or untyped Java
variables
and serializable Java objects;
state machine, Petri nets, or pi-calculus based conversation protocols;
context-dependent inline reactions for asynchronous message exchange;
ability to distribute mobile rulebases to remote agents;
Communicator class for simplified embedding of Prova agents in Java and
Web
applications;
Prova Universal Message Object gateway for reactive agents on ESB.
Multi-threaded Swing programming with Prova Java calls and reaction rules.


Messaging Reaction Rules

Send a message
sendMsg(XID,Protocol,Agent,Performative,[Predicate|Args]|Context)
Receive a message
rcvMsg(XID,Protocol,Agent,Performative,[Predicate|Args]|Context)
Receive multiple messages
rcvMult(XID,Protocol,Agent,Performative,[Predicate|Args]|Context)

Description:
XID is the conversation identifier
Protocol: transport protocol e.g. self, jade, jms, esb
Agent: denotes the target or sender of the message
Performative: pragmatic context, e.g. FIPA ACL
[Predicate|Args] or Predicate(Arg1,..,Argn): Message payload


Example:
quot;Request – Responsequot; Flow with Delegation

% receive query and delegate it to another agent
rcvMsg(CID,esb, Requester, acl_query-ref, Query) :-
... (other goals) ...
sendMsg(Sub-CID,esb,Agent,acl_query-ref, Query),
rcvMsg(Sub-CID,esb,Agent,acl_inform-ref, Answer),
... (other goals)...
sendMsg(CID,esb,Agent,acl_inform-ref,Answer).

% answers query quot;Agentquot;
rcvMsg(XID, esb, From, Performative, [X|Args]):-
derive([X|Args]),
sendMsg(XID,esb,From, answer, [X|Args]).


Complex Event Messaging and Processing
- Semantics a la Petri nets and pi-calculus
- Workflow patterns

process_join() :-
iam(Me),
init_join(XID,join_1,[c(_),b(_)]),
fork_a_b(Me,XID).
fork_a_b(Me,XID) :-
rcvMsg(XID,self,Me,reply,a(1)),
fork_c_d(Me,XID).
fork_a_b(Me,XID) :-
rcvMsg(XID,self,Me,reply,b(1)),
join(Me,XID,join_1,b(1)).
fork_c_d(Me,XID) :-
rcvMsg(XID,self,Me,reply,c(1)),
% Tell the join join_1 that a new pattern is ready
join(Me,XID,join_1,c(1)).

% The following rule is invoked by join once all the inputs are assembled.
join_1(Me,XID,Inputs) :-
println([quot;Joined for XID=quot;,XID,quot; with inputs: quot;,Inputs]).

% Prints
% Joined for XID=agent@hostname001 with inputs [[b,1],[c,1]]


State machines based conversations
query_ref( Product )
0 1

[ product(Product,_) ]
[ !product(Product,_) ]

2(yes) 2(no)
entry/ ^Buyer.agree(Product) entry/ ^Buyer.refuse(Product)
entry/ ^Buyer.inform_result(Product)

request( Product,Price ) 4(refuse)
[ !Price>SellerPrice ] entry/ ^Buyer.refuse(Product,Price)
3

entry/ ^self.product(Product,SellerPrice)

[ Price>SellerPrice ]
4(agree)

entry/ ^Buyer.agree(Product,Price)
entry/ ^Buyer.inform_done(Product,Price)

directbuy_seller_1(XID,Protocol,From,Product) :-
product(Product|_),
!,
sendMsg(XID,Protocol,From,agree,Product,seller),
sendMsg(XID,Protocol,From,inform_result,Product,seller),
directbuy_seller_2(yes,XID,Protocol,From,Product).
directbuy_seller_1(XID,Protocol,From,Product) :-
sendMsg(XID,Protocol,From,refuse,Product,seller),
directbuy_seller_2(no,XID,Protocol,From,Product).
directbuy_seller_2(yes,XID,Protocol,From,Product) :-
!,
rcvMsg(XID,Protocol,From,request,[Product,Price],buyer),
product(Product,SellerPrice),
directbuy_seller_3(XID,Protocol,From,Product,Price,SellerPrice).
directbuy_seller_2(no,XID,Protocol,From,Product).

Other Rule Engines: OO jDREW

OO jDREW is used for personal agents in
Rule Responder
Two modes of Rule Execution:
Bottom-up (forward reasoning)
Top-down (backward reasoning)

Rule Responder primarily uses top-down
Supports rules in the following formats:
POSL (Positional Slotted presentation syntax)
RuleML (XML syntax, can be generated from POSL)


Rule Responder

Use Cases


Use Case: Expert Finding (1)


Use Case: Expert Finding (2)

Expert


Use Case: Job/Task Scheduling
% Manager

upload_mobile_code(Remote,File) :
Writer = java.io.StringWriter(), % Opening a file fopen(File,Reader),
copy(Reader,Writer),
Text = Writer.toString(),
SB = StringBuffer(Text),
sendMsg(XID,esb,Remote,eval,consult(SB)).

% Service (Contractor)

rcvMsg(XID,esb,Sender,eval,[Predicate|Args]):-derive([Predicate|Args]).

Contract Net Protocol


Use Case: Interactive Inductive Logic
Programming with Conversations


Use Case:
Symposium Organization (Virtual Organization)


Use Case: Virtual Organization (3)
Request / Response Conversation


Example: Request Registration Fee (1)
Query from External Agent (e.g. Web form)
<RuleML ...>
<Message mode=quot;outboundquot; directive=quot;queryquot;>
...
<content>
<Atom> <Rel>computeFee</Rel>
<Ind>Adrian Paschke</Ind>
<Var>Fee</Var>
</Atom>
</content>
</Message>
</RuleML>
Delegation Logic of Organizational Agent (Prova)
fee(Phase,Fee):-
% look-up responsible agent
assigned(Agent,ruleml2007_Submission,ruleml2007_responsible),
% query permission from responsible agent
sendMsg(XID,esb,Agent, quot;queryquot;, fee(Phase,Fee)),
% receive answers multiple times
rcvMult(XID,esb,Agent,quot;answerquot;, fee(Phase,Fee)).


Example: Request Registration Fee (2)
Rule of Personal Program Chair Agent: (Prova)
computeFee(Participant,Fee,T):-
holdsAt(open(RegistrationPhase),T),
fee(RegistrationPhase,BasicFee),
sendMsg(XID,esb,ruleml2007_PublicityChair,query,
registrationDiscount(Participant,BasicFee,1,Discount,Cost)),
rcvMsg(XID,esb,ruleml2007_PublicityChair, answer,
registrationDiscount(Participant,BasicFee,1,Discount,Cost)),
Fee = Cost - (Cost * Discount).
fee(earlyRegistration,currency_Dollar:500).
fee(regularRegistration,currency_Dollar:600).
Rule of Publicity Chair Agent: (OO jDrew)
%This rule is used to calculate the discount of registration if
% the organization is a collaboration partner.
registrationDiscount(?Organization:collaborationPartner,?Regist
rationCost:real,?NumberOfRegistrations:integer,?IndividualDisco
untCost:real,?TotalCost:real) :-
multiply(?IndividualDiscountCost:real,
?RegistrationCost:real,0.9:real),
multiply(?TotalCost:real,
?NumberOfRegistrations:integer,?IndividualDiscountCost:real).

Meeting Scheduling


Review Allocation


Registration Process


Use Case:
Rule Based Service Level Agreement Project (1)

http://ibis.in.tum.de/projects/rbsla/ 2007
50 2nd International Conference on the Pragmatic Web Rule Responder © Adrian Paschke

Rule Based Service Level Agreement Project (2)

1. Service Dashboard
• (Monitoring and
Contract Tracking)
2. RBSLA Editor / Contract
Manager
• (Contract Mgt. and
Authoring)

Conclusion: Rule-Responder A RuleML-based Pragmatic
Agent Web (1)
Develops an effective methodology and an efficient
infrastructure to interchange and reuse knowledge on the
Web (ontologies and rules) and communicate contextual
actions

Adds a pragmatic rule-based layer (Pragmatic Web),
defines the rules for using information resources and ontologies to support
human agents in their decisions and react partially self-autonomously by
means of automated agents or services
Blends and tightly combines the ideas of multi-agent
systems, distributed rule management systems, and service
oriented and event driven architectures
Addresses real-world software engineering needs for a
highly distributed, open, interoperable, efficient and scalable
Semantic Web service and agent infrastructure
Design Science Research Approach

Conclusion: Rule-Responder A RuleML-based Pragmatic
Agent Web (1)

Demonstrates the interoperation of various distributed
platform-specific rule execution environments based on
Reaction RuleML as a platform-independent rule
interchange format interchanged over an enterprise service
bus as transport middleware
Applies rule-based technologies to the management of
virtual organizations and collaborative teams
Applies negotiation and distributed coordination
mechanisms of rule-based complex event processing and
rule-based workflow like reaction rule patterns
Demonstrates the integration and interoperation of rule
standards (RuleML), Object-Oriented programming (Java)
and Semantic Web (RDF, RDFS, OWL) and metadata
standards (e.g. iCal, vCard, FOAF)

Applications and Next Steps
Applications of the Pragmatic Agent Web and the Rule
Responder middleware in different projects

Rule Responder: http://responder.ruleml.org/
Reaction RuleML: http://ibis.in.tum.de/research/ReactionRuleML/
Prova Agent Architecture: http://www.prova.ws/
Prova Workflow Patterns: http://www.prova.ws/csp/?q=taxonomy/term/11
Rule Based Service Level Agreements: http://ibis.in.tum.de/projects/rbsla/

Next steps
Integration of further rule engines into the middleware (Rule Responder project)
Extending the Pragmatic Foundations of Rule Responder
Syntactical standardization issues (Reaction RuleML, Rule Interchange Format)
Running projects:
FungalWeb project with Rule Responder agents to answer queries on chemical compunds
(Chebi), enzymes (Mesh, EC classificaiton), species; Chebi and enzyme classification (EC)
DILP (Distributed Inductive Logic Programming) for Mining Multi-Relation Data in Bioinformatics
DoReMoPat: Domain-specific Reference Models for Complex Event Patterns
Rule Responder Expert Finder

Rule Responder: A RuleML-based Pragmatic Agent Web

http://responder.ruleml.org

Sourceforge SVN:

https://mandarax.svn.sourceforge.net/
svnroot/mandarax.

Sub-project quot;pragmatic-agent-webquot;


Rule Responder - Pragmatic Agent Web Using RuleML

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (6)

Similaire à Rule Responder - Pragmatic Agent Web Using RuleML

Similaire à Rule Responder - Pragmatic Agent Web Using RuleML (20)

Dernier

Dernier (20)

Rule Responder - Pragmatic Agent Web Using RuleML