public class NCIntentSolver extends Object
NCModel.query(NCQueryContext)
method. This is the non-declarative part of the model and cannot be defined outside of JVM code as this
method is responsible for user-defined converting of parsed user input into specific action.
Although this method can be implemented "manually" by manually parsing query context and its list of
parsing variants - it is often more complex and error-prone than necessary.
intent
, and let this solver select the best matching intent for a given the user input.
Each intent defines a pattern of the user input and associated action to take when that pattern is detected.
While selecting the best matching intent the solver uses sophisticated NLP analysis, resolves anaphores via
conversational context and can ask user for missing terms. If more than one intent is registered the solver
tries to find the most specific intent that matches user input.
solve(NCQueryContext)
method as implementation
for NCModel.query(NCQueryContext)
method on your model. For example, if you use
NCModelBuilder
class you can use its NCModelBuilder.setQueryFunction(Function)
method to set this up.
NCModelProvider
interface implementation. Once configured
the model is deployed and it will use the set token solver for resolving user input and converting it into actions.
To add an intent you will need to use simple DSL based on the following classes and interfaces:
+---------------+ +-------------------+ |An intent is a collection ofCONV_INTENT
| |NON_CONV_INTENT
| +-------+-------+ +----------+--------+ | | | | | +----------+ | +---^+INTENT
+^------+ +----+-----+ | | +---o----+ |TERM
| +---+----+ | | +---0----+ |ITEM
| +---+----+ | | +-----0-------+ +----^+ /predicate/ |^---+-----------+------------+------------+-----------+----------+ | +-----^-------+ | | | | | | | | | | | | | | | | | | | | +----+---+ +---+---+ +---+---+ +--------+ +--------+ +-------+ +------+ |RULE
| |AND
| |NOR
| |XNOR
| |NAND
| |XOR
| |OR
| +--------+ +-------+ +-------+ +--------+ +--------+ +-------+ +------+
TERMs
with a callback for when that intent is
selected. Intents can be ordered or unordered, conversational and non-conversational. Additionally to
INTENT
class there are two special subclasses that provide
convenient shortcuts for creating specific intents: CONV_INTENT
and
NON_CONV_INTENT
. Term represents a selector on semantic token either from the model or
the built-in one. Technically the term consists of one or more items
where each item is either
a rule
or one of the logical combinators. Few important notes:
TERM
, ITEM
and RULE
have multiple convenient
shortcut constructors to shorten the DSL notation.
TERM
can represent a complex match on a token beyond just matching on token ID. Employing
multiple ITEMs
with combinators the TERM
can encode a sophisticated
matching logic.
ITEMs
in the TERM
is not taking into consideration when
matching, i.e. a term (i.e. its items) is matched when it's found anywhere in the input string.
TERMs
should be found in the input string for the intent to match.
NCTokenSolver solver = new NCTokenSolver( "time-solver", false, __ -> { throw new NCRejection("Seems unrelated (check city name)."); } ); // Check for exactly one 'x:time' token without looking into conversation. // That's an indication of asking for local time. Note that non-conversational intents are // always more specific that conversational intents since they deal only with the most // recent user input (i.e. without looking into conversation history). solver.addIntent( new NON_CONV_INTENT("id == x:time", 1, 1), // Term index 0. this::onLocalMatch ); // Check for exactly one 'x:time' and one 'nlp:geo' CITY token including conversation // context. That can be either local or remote time. solver.addIntent( new CONV_INTENT( new TERM("id == x:time", 1, 1), // Term index 0. new TERM(new AND( // Term index 1. "id == nlp:geo", "~GEO_KIND == CITY" ), 1, 1) ), this::onRemoteMatch );
Modifier and Type | Class and Description |
---|---|
static class |
NCIntentSolver.AND
AND-combinator for token predicates.
|
static class |
NCIntentSolver.CONV_INTENT
Convenient adapter for conversational intent.
|
static class |
NCIntentSolver.INTENT
Token solver intent.
|
static interface |
NCIntentSolver.IntentCallback
Callback provided by the user for an intent when it is matched.
|
static class |
NCIntentSolver.ITEM
Item is a token predicate plus quantifiers.
|
static class |
NCIntentSolver.NAND
NAND-combinator for token predicates.
|
static class |
NCIntentSolver.NON_CONV_INTENT
Convenient adapter for non-conversational intent.
|
static class |
NCIntentSolver.NOR
NOR-combinator for token predicates.
|
static class |
NCIntentSolver.OR
OR-combinator for token predicates.
|
static interface |
NCIntentSolver.Predicate
Marker type of pattern items.
|
static class |
NCIntentSolver.RULE
Binary operator based on declarative condition over
token . |
static class |
NCIntentSolver.TERM
Term is a building block of the
INTENT . |
static class |
NCIntentSolver.XNOR
XNOR (exclusive NOR)-combinator for token predicates.
|
static class |
NCIntentSolver.XOR
XOR (exclusive OR)-combinator for token predicates.
|
Constructor and Description |
---|
NCIntentSolver()
Creates new default token solver.
|
NCIntentSolver(String name)
Creates new named token solver with given parameters and default not-found function.
|
NCIntentSolver(String name,
Supplier<NCQueryResult> notFound)
Creates new named token solver with given parameters.
|
Modifier and Type | Method and Description |
---|---|
NCIntentSolver |
addIntent(NCIntentSolver.INTENT intent,
NCIntentSolver.IntentCallback fun)
Adds given intent, its ID and its callback function to this solver.
|
NCQueryResult |
solve(NCQueryContext ctx)
Finds the best matching intent for given sentence and calls its callback function to get the final query result.
|
public NCIntentSolver()
null
name, no multi-match and
default not-found function that throws NCRejection
exception. This is equivalent to:
this(null, false, null);
public NCIntentSolver(String name)
NCRejection
exception with generic error message.name
- Name of the solver (for informational purpose only).public NCIntentSolver(String name, Supplier<NCQueryResult> notFound)
name
- Name of the solver (for informational purpose only).notFound
- Custom not-found function. This function will be called when no matching intent can
be found for given sentence. If null
, a default implementation will be used
that throws NCRejection
exception with generic error message.public NCIntentSolver addIntent(NCIntentSolver.INTENT intent, NCIntentSolver.IntentCallback fun)
intent
- Intent to add.fun
- A callback function that will be called when given intent is found to be the best match.public NCQueryResult solve(NCQueryContext ctx) throws NCRejection
NCRejection
exception with default rejection message will be thrown.ctx
- Sentence's context to find the best match for.NCRejection
Copyright © 2013-2019 NLPCraft Project. All rights reserved.