[rules-users] Distributed Drools

[Davide Sottara]

Daniel, this is a really timely message.
In the past, we did an initial experiment, creating a drools-5.x
based agent compatible with the FIPA spec.
The code is here
https://github.com/droolsjbpm/drools-mas

We are now planning to migrate to 6.x/KIE, probably over summer.
We may want to join efforts.
I'm bcc-ing Mauricio and Esteban, who worked on the initial implementation,
and of course Mark who may provide more information.

As far as I know, there is some independent work going on
regarding the creation of an "execution container". I don't know the specs,
but maybe it could also be exploited as an underlying platform.

We may try to arrange a moment to get together, in IRC or hangout.

I am definitely interested in seeing this move forward
Best
Davide


On 04/23/2014 04:53 PM, Daniel Souza wrote:
> Hi all, I'm looking for some distributed solution available with drools. I
> want to create a distributed Multi-agent architecture for my project using a
> shared working memory.
>
> Searching for solutions, I found the DJess and Octopus solution that use the
> Jess inference engine.
> For Drools, I found this one:
> http://www.plugtree.com/making-a-non-persistent-ha-knowledge-session/
> It seems that Kie is flexible enough to distribute the knowledge session in
> local ksessions, but I think that the ha-ksession doesn't provide a shared
> working memory to different kbases. Seeing the sample project, there's just
> one rule set (drl) with only one rule. I can use as a sample model to do
> what I want to do. This project showed me how I can extend the Kie and
> implement my own.
> I'm not familiar with Drools 6 yet, but I'm reading papers about distributed
> Rule-Based Systems concerning Multi-Agent Systems solutions and I didn't
> find any solution using Drools. The majority solutions were provided using a
> shared working memory with local copies. 
>
> *Than, it gives me a question: is it possible to create a shared working
> memory with Drools?*
>
> To refresh What I mean, there's an old paper showing differences between
> Blackboard Systems and Rule-Based Systems (see Figure 1).
>
> <http://drools.46999.n3.nabble.com/file/n4029338/production_systems_vs_blackboard_systems.png> 
>
> In Figure 1, the Blackboard is a shared working memory to insert facts,
> where each knowledge source (KS) is activated according with the facts
> inserted. Each KS is a specific expert with your own rules set that look for
> the blackboard to produce partial solutions that can be seen as new facts to
> be inserted in the blackboard. These partial solutions can activate more KS
> to produce new partial solutions until the final solution be reached. In
> contrast, in production systems, we build a knowledge base with a set o
> rules that can be activated according with facts inserted in a local working
> memory (there's no shared working memory between others kbases with their
> own rules set).
>
> In DJess, the authors introduce a model for distributing rule-based
> inference systems called Web of Inference Systems (WoIS). Each member of
> WoIS is composed of an inference system (IS) and a rule base, while all ISs
> operate on a single Shared Working Memory (SWM). WoIS is controlled by a
> dedicated
> component called manager (M). Each IS holds a copy of a part of the SWM in
> its local working memory, while all ISs run independently in parallel. This
> model was utilized to implement a distributed version of Jess called DJess.
> Synchronization between interfering rules is achieved by means of shadow
> facts and ghost facts. A shadow fact is a Jess fact linked to a Java bean
> object. Each shared fact is implemented as a shadow fact, and thus an
> associated Java bean object is created. All the proxies corresponding to the
> same shared fact are linked together by means of a Java remote object called
> ghost fact. Access of the ISs to the ghost facts are synchronized by
> acquiring locks during the transition from the conflict resolution stage to
> the act stage of an inference cycle.
>
> If not were done yet, I want to implement my own approach using Drools. I
> don't know if I can reach the final solution using Drools, but it seems the
> the Kie is flexible enough to be extend and I implement something. I'm
> planning to use the FIPA Subscribe protocol to synchronize the Shared
> Working Memory with a local working memory for each agent.
>
> "The FIPA Subscribe Interaction Protocol (IP) allows an agent to request a
> receiving agent to perform an action on subscription and subsequently when
> the referenced object changes"
> <http://fipa.org/specs/fipa00035/SC00035H.html>  
>
> Regards,
> Daniel Souza 
>
>
>
> --
> View this message in context: http://drools.46999.n3.nabble.com/Distributed-Drools-tp4029338.html
> Sent from the Drools: User forum mailing list archive at Nabble.com.
> _______________________________________________
> rules-users mailing list
> rules-users at lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-users
>