Lama is a software platform devoted to the design of Knowledge-Based Systems (KBS), i.e. to both knowledge base and reasoning engine design. It provides experts or engine designers with a generic environment, composed of common tools that can be shared among different KBS.

The platform offers both experts and designers a high level of abstraction for their work, which is independent of any programming language, while rich enough to express their needs. First, experts can share graphical knowledge base visualisation interfaces and an expertise description language. Second,engine designers can configure their engines by means of a library of generic and reusable components. They can also test, compare, reuse or modify different engines in a unified framework.

Target Users

The users of Lama fall into two categories: designers and experts. Designers of KBS engines can carry their design at a level of abstraction close to the design process one, freeing them from implementation details, by means of an object-oriented framework (BLOCKS library). The library is easy to extend and to adapt to new reaso ning needs. Domain experts also benefit from the implementation-independent approach. All the engines share the same common toolbox for knowledge base development and use, so it is easy to try different engine strategies in order to find the most suitable one, without major modifi cation of the knowledge base description. The tools may be adapted to all engine specifics and accordingly guide the expert during the knowledge base development.

  An engine designer builds a new engine (or modifies an existing one) and customizes the expertise description language and the tools for future expert needs

  Afterwards, experts use the customized tools (mainly the expertise description language and its interfaces) to create a knowledge base corresponding to a class of applications in their domain.

Compositional perspective

In problem solving, several reasoning strategies can be applied. Depending on the task to solve, these strategies are different and use information about different entities, organized in different ways. When solving a complex task, the strategy can be decomposed into more simple «reasoning steps». Furthermore, for one task more or less complex versions of a reasoning strategy may be needed, depending on the application domain specifics.

LAMA's framework provides designers with data structures for knowledge representations and reasoning components that implement small grain-size «reasoning steps». Standard, general purpose reasoning components are e.g. choosing between a set of elements, matching two elements, testing a condition, etc. These components are free of implementation details, for the designers to configure or adapt engines, based on abstract reasoning step, but independently of implementation issues. This allows easy versioning of engines and limits code re-writing.

LAMA Architecture

The core of the platform is the BLOCKS object- oriented framework, which is a library of reasoning components (i.e. structures and instructions) These abstract components hide the underlying implementation language. The library is divided into general and task-specific layers. A task-specific layer focusses on the primary needs of a task. For example, if the target task is planning its layer will implement reusable reasoning components to perform different kinds of planning.

Lama provides two kinds of interfaces for engine designers and experts:

Papers and related work


Related work

 Projet Stars 
2004 route des Lucioles - BP 93 
06902 Sophia Antipolis Cedex