# Custom NLU Components
You can create a custom component to perform a specific task which NLU doesn’t currently offer (for example, sentiment analysis).
Below is the specification of the [`rasa.nlu.components.Component`](https://legacy-docs-v1.rasa.com/1.10.3/api/custom-nlu-components/#rasa.nlu.components.Component "rasa.nlu.components.Component") class with the methods you’ll need to implement.
Note
There is a detailed tutorial on building custom components [here](https://blog.rasa.com/enhancing-rasa-nlu-with-custom-components/).
You can add a custom component to your pipeline by adding the module path.
So if you have a module called `sentiment`
containing a `SentimentAnalyzer` class:
```
pipeline:
- name: "sentiment.SentimentAnalyzer"
```
Also be sure to read the section on the [Component Lifecycle](https://legacy-docs-v1.rasa.com/1.10.3/nlu/choosing-a-pipeline/#component-lifecycle).
To get started, you can use this skeleton that contains the most important
methods that you should implement:
| | |
| --- | --- |
| ```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
``` | ```
import typing
from typing import Any, Optional, Text, Dict, List, Type
from rasa.nlu.components import Component
from rasa.nlu.config import RasaNLUModelConfig
from rasa.nlu.training_data import Message, TrainingData
if typing.TYPE_CHECKING:
from rasa.nlu.model import Metadata
class MyComponent(Component):
"""A new component"""
@classmethod
def required_components(cls) -> List[Type[Component]]:
"""Specify which components need to be present in the pipeline."""
return []
defaults = {}
language_list = None
def __init__(self, component_config: Optional[Dict[Text, Any]] = None) -> None:
super().__init__(component_config)
def train(
self,
training_data: TrainingData,
config: Optional[RasaNLUModelConfig] = None,
**kwargs: Any,
) -> None:
pass
def process(self, message: Message, **kwargs: Any) -> None:
pass
def persist(self, file_name: Text, model_dir: Text) -> Optional[Dict[Text, Any]]:
pass
@classmethod
def load(
cls,
meta: Dict[Text, Any],
model_dir: Optional[Text] = None,
model_metadata: Optional["Metadata"] = None,
cached_component: Optional["Component"] = None,
**kwargs: Any,
) -> "Component":
if cached_component:
return cached_component
else:
return cls(meta)
``` |
Note
If you create a custom tokenizer you should implement the methods of `rasa.nlu.tokenizers.tokenizer.Tokenizer`.
Note
If you create a custom featurizer you should return a sequence of features.
## Component
_class_`rasa.nlu.components.``Component`( _component_config=None_)
A component is a message processing unit in a pipeline.
Components are collected sequentially in a pipeline. Each component
is called one after another. This holds for
initialization, training, persisting and loading the components.
E.g. to process an incoming message, the `process` method of
each component will be called. During the messaging processing,
components can pass information to other components.
### classmethod required_components()
Specify which components need to be present in the pipeline.
Returns
The list of class names of required components.
Return type
`List`[`Type`[`Component`]]
### classmethod required_packages()
Specify which python packages need to be installed.
Returns
The list of required package names.
Return type
`List`[ `str` ]
### classmethod create(_component_config_, _config_)
Creates this component (e.g. before training is started).
Returns
The created component.
Return type
[`Component`](https://legacy-docs-v1.rasa.com/1.10.3/api/custom-nlu-components/#rasa.nlu.components.Component "rasa.nlu.components.Component")
### provide_context()
Initialize this component for a new pipeline.
Returns
The updated component configuration.
Return type
`Optional`[`Dict`[`str`, `Any`]]
### train(_training_data_, _config=None_, _**kwargs_)
Train this component.
Parameters
- **training_data** – The `rasa.nlu.training_data.training_data.TrainingData`.
Return type
`None`
### process(_message_, _**kwargs_)
Process an incoming message.
Parameters
**message** – The `rasa.nlu.training_data.message.Message` to process.
Return type
`None`
### persist(_file_name_, _model_dir_)
Persist this component to disk for future loading.
Returns
An optional dictionary with any information about the stored model.
Return type
`Optional`[`Dict`[`str`, `Any`]]
### prepare_partial_processing(_pipeline_, _context_)
Sets the pipeline and context used for partial processing.
Return type
`None`
### partially_process(_message_)
Allows the component to process messages during training.
Returns
The processed `rasa.nlu.training_data.message.Message`.
Return type
`Message`
### classmethod can_handle_language(_language_)
Check if component supports a specific language.
Returns
True if component can handle specific language, False otherwise.
Return type
`bool`