KeyBERT

https://maartengr.github.io/KeyBERT/
Admin
KeyBERT is a minimal and easy-to-use keyword extraction technique that leverages BERT embeddings to...
Tokens:64,256
Snippets:329
Trust Score:9.7
Update:2 days ago
Show doc for...
Tokens:
Raw
### Install KeyBERT via pip

Source: https://maartengr.github.io/KeyBERT/

Basic installation command for KeyBERT from PyPI.

```bash
pip install keybert
```

--------------------------------

### Install LiteLLM package

Source: https://maartengr.github.io/KeyBERT/guides/llms.html

Install the litellm package to use any closed-source LLM with KeyLLM.

```bash
pip install litellm
```

--------------------------------

### Install langchain and openai packages

Source: https://maartengr.github.io/KeyBERT/api/langchain.html

Required installation commands for using the LangChain class.

```bash
pip install langchain
```

```bash
pip install openai
```

--------------------------------

### Sample documents for KeyLLM

Source: https://maartengr.github.io/KeyBERT/guides/keyllm.html

Example documents used to demonstrate KeyLLM. Documents 1 and 2 are similar, while document 3 is about a different subject.

```python
documents = [
"The website mentions that it only takes a couple of days to deliver but I still have not received mine.",
"I received my package!",
"Whereas the most powerful LLMs have generally been accessible only through limited APIs (if at all), Meta released LLaMA's model weights to the research community under a noncommercial license."
]
```

--------------------------------

### Install KeyBERT with optional backends

Source: https://maartengr.github.io/KeyBERT/

Optional installations for additional transformers and language backends: flair, gensim, spacy, and use.

```bash
pip install keybert[flair]
```

```bash
pip install keybert[gensim]
```

```bash
pip install keybert[spacy]
```

```bash
pip install keybert[use]
```

--------------------------------

### Install cohere

Source: https://maartengr.github.io/KeyBERT/api/cohere.html

Install the cohere package using pip.

```bash
pip install cohere
```

--------------------------------

### Install LangChain

Source: https://maartengr.github.io/KeyBERT/guides/llms.html

Install the langchain package using pip.

```bash
pip install langchain
```

--------------------------------

### Install openai package

Source: https://maartengr.github.io/KeyBERT/api/openai.html

Install the required openai package before using the OpenAI class.

```bash
pip install openai
```

--------------------------------

### Install keyphrase-vectorizers package

Source: https://maartengr.github.io/KeyBERT/guides/countvectorizer.html

Install the KeyphraseVectorizers package using pip.

```bash
pip install keyphrase-vectorizers
```

--------------------------------

### Working example with matching parameters

Source: https://maartengr.github.io/KeyBERT/guides/quickstart.html

This example works because the parameters min_df and stop_words are identical in both extract_embeddings and extract_keywords calls.

```python
from keybert import KeyBERT

kw_model = KeyBERT()
doc_embeddings, word_embeddings = kw_model.extract_embeddings(docs, min_df=1, stop_words="english")
keywords = kw_model.extract_keywords(docs, min_df=1, stop_words="english",
                                     doc_embeddings=doc_embeddings,
                                     word_embeddings=word_embeddings)
```

--------------------------------

### Use LiteLLM with OpenAI example

Source: https://maartengr.github.io/KeyBERT/guides/llms.html

Set the OPENAI_API_KEY environment variable and create a LiteLLM instance with a model name (e.g., gpt-3.5-turbo).

```python
import os
from keybert.llm import LiteLLM
from keybert import KeyLLM

# Select LLM
os.environ["OPENAI_API_KEY"] = "sk-..."
llm = LiteLLM("gpt-3.5-turbo")

# Load it in KeyLLM
kw_model = KeyLLM(llm)
```

--------------------------------

### Install light-weight KeyBERT

Source: https://maartengr.github.io/KeyBERT/changelog.html

Command to install a light-weight version of KeyBERT without dependencies, using scikit-learn and model2vec.

```bash
pip install keybert --no-deps scikit-learn model2vec
```

--------------------------------

### Example output of keyword extraction

Source: https://maartengr.github.io/KeyBERT/guides/keyllm.html

Shows the resulting keywords for the example documents, with each sublist corresponding to a document.

```python
[['Website',
  'Delivery',
  'Timeframe',
  'Mention',
  'Order fulfillment',
  'Not received',
  'Waiting'],
 ['Package', 'Received', 'Confirmation', 'Delivery', 'Order fulfillment'],
 ['LLMs', 'Limited APIs', 'Meta', 'LLaMA', 'Model weights', '']]
```

--------------------------------

### Create Custom Backend with BaseEmbedder

Source: https://maartengr.github.io/KeyBERT/guides/embeddings.html

Shows how to create a custom embedding backend by subclassing keybert.backend.BaseEmbedder. The example implements a SentenceTransformer backend and passes it to KeyBERT.

```python
from keybert.backend import BaseEmbedder
from sentence_transformers import SentenceTransformer

class CustomEmbedder(BaseEmbedder):
    def __init__(self, embedding_model):
        super().__init__()
        self.embedding_model = embedding_model

    def embed(self, documents, verbose=False):
        embeddings = self.embedding_model.encode(documents, show_progress_bar=verbose)
        return embeddings

# Create custom backend
distilbert = SentenceTransformer("paraphrase-MiniLM-L6-v2")
custom_embedder = CustomEmbedder(embedding_model=distilbert)

# Pass custom backend to keybert
kw_model = KeyBERT(model=custom_embedder)
```

--------------------------------

### Minimal KeyBERT keyword extraction example

Source: https://maartengr.github.io/KeyBERT/

Shows the most minimal usage: import KeyBERT, define a document, create a model, and extract keywords.

```python
from keybert import KeyBERT

doc = """
         Supervised learning is the machine learning task of learning a function that
         maps an input to an output based on example input-output pairs. It infers a
         function from labeled training data consisting of a set of training examples.
         In supervised learning, each example is a pair consisting of an input object
         (typically a vector) and a desired output value (also called the supervisory signal).
         A supervised learning algorithm analyzes the training data and produces an inferred function,
         which can be used for mapping new examples. An optimal scenario will allow for the
         algorithm to correctly determine the class labels for unseen instances. This requires
         the learning algorithm to generalize from the training data to unseen situations in a
         'reasonable' way (see inductive bias).
      """
kw_model = KeyBERT()
keywords = kw_model.extract_keywords(doc)
```

--------------------------------

### Use KeyLLM with OpenAI (legacy API key)

Source: https://maartengr.github.io/KeyBERT/changelog.html

For KeyBERT version 0.8.0, set the OpenAI API key globally and create an OpenAI LLM instance without a client. This example is from the initial KeyLLM release.

```python
import openai
from keybert.llm import OpenAI
from keybert import KeyLLM

# Create your LLM
openai.api_key = "sk-..."
llm = OpenAI()

# Load it in KeyLLM
kw_model = KeyLLM(llm)
```

--------------------------------

### Extract keywords with keyphrase_ngram_range=(1, 1)

Source: https://maartengr.github.io/KeyBERT/

Shows how to set keyphrase_ngram_range to (1, 1) to get single-word keywords, with example output.

```python
>>> kw_model.extract_keywords(doc, keyphrase_ngram_range=(1, 1), stop_words=None)
[('learning', 0.4604),
 ('algorithm', 0.4556),
 ('training', 0.4487),
 ('class', 0.4086),
 ('mapping', 0.3700)]
```

--------------------------------

### Extract keyphrases with keyphrase_ngram_range=(1, 2)

Source: https://maartengr.github.io/KeyBERT/

Shows how to set keyphrase_ngram_range to (1, 2) to get keyphrases of one or two words, with example output.

```python
>>> kw_model.extract_keywords(doc, keyphrase_ngram_range=(1, 2), stop_words=None)
[('learning algorithm', 0.6978),
 ('machine learning', 0.6305),
 ('supervised learning', 0.5985),
 ('algorithm analyzes', 0.5860),
 ('learning function', 0.5850)]
```

--------------------------------

### LiteLLM.__init__(model, prompt, system_prompt, generator_kwargs, delay_in_seconds, verbose)

Source: https://maartengr.github.io/KeyBERT/api/litellm.html

Initializes the LiteLLM instance with model, prompt, system prompt, generator kwargs, delay, and verbosity settings.

```APIDOC
## LiteLLM.__init__(model, prompt, system_prompt, generator_kwargs, delay_in_seconds, verbose)

### Description
Initializes the LiteLLM instance with model, prompt, system prompt, generator kwargs, delay, and verbosity settings.

### Method
Python constructor

### Signature
```python
def __init__(
    self,
    model: str = "gpt-3.5-turbo",
    prompt: str = None,
    system_prompt: str = "You are a helpful assistant.",
    generator_kwargs: Mapping[str, Any] = {},
    delay_in_seconds: float = None,
    verbose: bool = False,
)
```

### Parameters
- **model** (str) - Optional - Model to use within LiteLLM, defaults to OpenAI's `"gpt-3.5-turbo"`.
- **prompt** (str) - Optional - The prompt to be used in the model. If no prompt is given, `self.default_prompt_` is used instead. NOTE: Use `"[DOCUMENT]"` in the prompt to decide where the document needs to be inserted.
- **system_prompt** (str) - Optional - The message that sets the behavior of the assistant. It's typically used to provide high-level instructions for the conversation.
- **generator_kwargs** (Mapping[str, Any]) - Optional - Kwargs passed to `litellm.completion` for fine-tuning the output.
- **delay_in_seconds** (float) - Optional - The delay in seconds between consecutive prompts in order to prevent RateLimitErrors.
- **verbose** (bool) - Optional - Set this to True if you want to see a progress bar for the keyword extraction.

### Usage Example
```python
import os
from keybert.llm import LiteLLM

# Select LLM
os.environ["OPENAI_API_KEY"] = "sk-..."
llm = LiteLLM("gpt-3.5-turbo")

# You can also use a custom prompt:
prompt = "I have the following document: [DOCUMENT] \nThis document contains the following keywords separated by commas: '"
llm = LiteLLM("gpt-3.5-turbo", prompt=prompt)
```
```

--------------------------------

### Basic usage of OpenAI with KeyLLM

Source: https://maartengr.github.io/KeyBERT/api/openai.html

Create an OpenAI client, instantiate the OpenAI LLM, load it into KeyLLM, and extract keywords from a document.

```python
import openai
from keybert.llm import OpenAI
from keybert import KeyLLM

# Create your LLM
client = openai.OpenAI(api_key=MY_API_KEY)
llm = OpenAI(client)

# Load it in KeyLLM
kw_model = KeyLLM(llm)

# Extract keywords
document = "The website mentions that it only takes a couple of days to deliver but I still have not received mine."
keywords = kw_model.extract_keywords(document)
```

--------------------------------

### OpenAI(client, model='gpt-3.5-turbo-instruct', generator_kwargs={}, prompt=None, system_prompt='You are a helpful assistant.', delay_in_seconds=None, exponential_backoff=False, chat=False, verbose=False)

Source: https://maartengr.github.io/KeyBERT/api/openai.html

Initializes an OpenAI LLM instance for use with KeyLLM. The constructor accepts an OpenAI client and various configuration parameters to control model selection, prompting, rate limiting, and chat mode.

```APIDOC
## OpenAI(client, model='gpt-3.5-turbo-instruct', generator_kwargs={}, prompt=None, system_prompt='You are a helpful assistant.', delay_in_seconds=None, exponential_backoff=False, chat=False, verbose=False)

### Description
Initializes an OpenAI LLM instance for keyword extraction. This class uses the OpenAI API to generate keywords based on a given document and prompt.

### Method
Constructor

### Endpoint
N/A (SDK class constructor)

### Parameters
- **client** (openai.OpenAI) - Required - An `openai.OpenAI` client instance.
- **model** (str) - Optional - Model to use within OpenAI, defaults to `"text-ada-001"`. NOTE: If a `gpt-3.5-turbo` model is used, make sure to set `chat` to True. Default: `'gpt-3.5-turbo-instruct'`.
- **generator_kwargs** (Mapping[str, Any]) - Optional - Kwargs passed to `openai.Completion.create` for fine-tuning the output. Default: `{}`.
- **prompt** (str) - Optional - The prompt to be used in the model. If no prompt is given, `self.default_prompt_` is used instead. NOTE: Use `"[DOCUMENT]"` in the prompt to decide where the document needs to be inserted. Default: `None`.
- **system_prompt** (str) - Optional - The message that sets the behavior of the assistant. It's typically used to provide high-level instructions for the conversation. Default: `'You are a helpful assistant.'`.
- **delay_in_seconds** (float) - Optional - The delay in seconds between consecutive prompts in order to prevent RateLimitErrors. Default: `None`.
- **exponential_backoff** (bool) - Optional - Retry requests with a random exponential backoff. A short sleep is used when a rate limit error is hit, then the requests is retried. Increase the sleep length if errors are hit until 10 unsuccesfull requests. If True, overrides `delay_in_seconds`. Default: `False`.
- **chat** (bool) - Optional - Set this to True if a chat model is used. Generally, this GPT 3.5 or higher. Default: `False`.
- **verbose** (bool) - Optional - Set this to True if you want to see a progress bar for the keyword extraction. Default: `False`.

### Request Example
```python
import openai
from keybert.llm import OpenAI
from keybert import KeyLLM

# Create your LLM
client = openai.OpenAI(api_key=MY_API_KEY)
llm = OpenAI(client)

# Load it in KeyLLM
kw_model = KeyLLM(llm)

# Extract keywords
document = "The website mentions that it only takes a couple of days to deliver but I still have not received mine."
keywords = kw_model.extract_keywords(document)
```

### Response
#### Success Response
- **keywords** (list) - List of extracted keywords.

#### Response Example
```python
keywords = kw_model.extract_keywords(document)
```
```

--------------------------------

### Define text and keyword model

Source: https://maartengr.github.io/KeyBERT/guides/countvectorizer.html

Sets up the document and KeyBERT model used throughout the tutorial.

```python
from keybert import KeyBERT

doc = """
         Supervised learning is the machine learning task of learning a function that
         maps an input to an output based on example input-output pairs.[1] It infers a
         function from labeled training data consisting of a set of training examples.[2]
         In supervised learning, each example is a pair consisting of an input object
         (typically a vector) and a desired output value (also called the supervisory signal).
         A supervised learning algorithm analyzes the training data and produces an inferred function,
         which can be used for mapping new examples. An optimal scenario will allow for the
         algorithm to correctly determine the class labels for unseen instances. This requires
         the learning algorithm to generalize from the training data to unseen situations in a
         'reasonable' way (see inductive bias).
      """
kw_model = KeyBERT()
```

--------------------------------

### KeyLLM.__init__(llm)

Source: https://maartengr.github.io/KeyBERT/api/keyllm.html

Initializes the KeyLLM class with a Large Language Model instance.

```APIDOC
## KeyLLM.__init__(llm)

### Description
Initializes the KeyLLM class with a Large Language Model (LLM) instance. This constructor stores the provided LLM for later use in keyword extraction.

### Method
Constructor

### Parameters
- **llm** (object) - Required - The Large Language Model to use for keyword extraction.

### Request Example
```python
from keybert._llm import KeyLLM

# Assuming an LLM instance is available
llm = SomeLLM()
keyllm = KeyLLM(llm)
```

### Response
No return value. The instance is initialized with the provided LLM.
```

--------------------------------

### KeyLLM __init__ method

Source: https://maartengr.github.io/KeyBERT/api/keyllm.html

Initializes the KeyLLM instance by storing the provided large language model in self.llm. The llm parameter is required.

```python
def __init__(self, llm):
    """KeyBERT initialization.

    Arguments:
        llm: The Large Language Model to use
    """
    self.llm = llm
```

--------------------------------

### Failing example with mismatched parameters

Source: https://maartengr.github.io/KeyBERT/guides/quickstart.html

This example will throw an error because the values for min_df and stop_words differ between extract_embeddings and extract_keywords.

```python
from keybert import KeyBERT

kw_model = KeyBERT()
doc_embeddings, word_embeddings = kw_model.extract_embeddings(docs, min_df=3, stop_words="dutch")
keywords = kw_model.extract_keywords(docs, min_df=1, stop_words="english",
                                     doc_embeddings=doc_embeddings,
                                     word_embeddings=word_embeddings)
```

--------------------------------

### Use Cohere with KeyLLM

Source: https://maartengr.github.io/KeyBERT/guides/llms.html

Initialize a Cohere client with your API key, create a KeyLLM instance, and extract keywords.

```python
import cohere
from keybert.llm import Cohere
from keybert import KeyLLM

# Create your OpenAI LLM
co = cohere.Client(my_api_key)
llm = Cohere(co)

# Load it in KeyLLM
kw_model = KeyLLM(llm)

# Extract keywords
keywords = kw_model.extract_keywords(MY_DOCUMENTS)
```

--------------------------------

### Usage with OpenAI

Source: https://maartengr.github.io/KeyBERT/api/litellm.html

Shows how to set up LiteLLM with OpenAI and use it with KeyLLM to extract keywords from a document. Requires setting the OPENAI_API_KEY environment variable.

```python
import os
from keybert.llm import LiteLLM
from keybert import KeyLLM

# Select LLM
os.environ["OPENAI_API_KEY"] = "sk-..."
llm = LiteLLM("gpt-3.5-turbo")

# Load it in KeyLLM
kw_model = KeyLLM(llm)

# Extract keywords
document = "The website mentions that it only takes a couple of days to deliver but I still have not received mine."
keywords = kw_model.extract_keywords(document)
```

--------------------------------

### OpenAI(client, model, prompt, system_prompt, generator_kwargs, delay_in_seconds, exponential_backoff, chat, verbose)

Source: https://maartengr.github.io/KeyBERT/api/openai.html

Initializes an OpenAI LLM instance for use with KeyLLM. Configures the OpenAI client, model, prompt, and generation settings.

```APIDOC
## OpenAI(client, model, prompt, system_prompt, generator_kwargs, delay_in_seconds, exponential_backoff, chat, verbose)

### Description
Initializes an OpenAI LLM instance for use with KeyLLM. Configures the OpenAI client, model, prompt, and generation settings.

### Method
Constructor

### Parameters
- **client** (openai.OpenAI) - Required - An OpenAI client instance.
- **model** (str) - Optional - Model to use within OpenAI, defaults to "gpt-3.5-turbo-instruct". NOTE: If a gpt-3.5-turbo model is used, set chat to True.
- **prompt** (str) - Optional - The prompt to be used in the model. If no prompt is given, self.default_prompt_ is used instead. Use "[DOCUMENT]" in the prompt to decide where the document needs to be inserted.
- **system_prompt** (str) - Optional - The message that sets the behavior of the assistant. Defaults to "You are a helpful assistant.".
- **generator_kwargs** (Mapping[str, Any]) - Optional - Kwargs passed to openai.Completion.create for fine-tuning the output.
- **delay_in_seconds** (float) - Optional - The delay in seconds between consecutive prompts to prevent RateLimitErrors.
- **exponential_backoff** (bool) - Optional - Retry requests with a random exponential backoff. If True, overrides delay_in_seconds.
- **chat** (bool) - Optional - Set to True if a chat model is used (GPT 3.5 or higher).
- **verbose** (bool) - Optional - Set to True to see a progress bar for keyword extraction.

### Usage Example
```python
import openai
from keybert.llm import OpenAI
from keybert import KeyLLM

# Create your LLM
client = openai.OpenAI(api_key=MY_API_KEY)
llm = OpenAI(client)

# Load it in KeyLLM
kw_model = KeyLLM(llm)

# Extract keywords
document = "The website mentions that it only takes a couple of days to deliver but I still have not received mine."
keywords = kw_model.extract_keywords(document)
```

### Custom Prompt Example
```python
prompt = "I have the following document: [DOCUMENT] \nThis document contains the following keywords separated by commas: '"
llm = OpenAI(client, prompt=prompt, delay_in_seconds=5)
```

### Chat Model Example
```python
llm = OpenAI(client, model="gpt-3.5-turbo", delay_in_seconds=10, chat=True)
```
```

--------------------------------

### Keywords extracted by KeyLLM

Source: https://maartengr.github.io/KeyBERT/guides/keyllm.html

Example output of the keywords extracted by KeyLLM for the sample documents.

```python
[['Website',
  'Delivery',
  'Mention',
  'Timeframe',
  'Not received',
  'Order fulfillment'],
 ['Package', 'Received', 'Delivery', 'Order fulfillment'],
 ['Powerful LLMs',
  'Limited APIs',
  'Meta',
  'Model weights',
  'Research community',
  '']]
```

--------------------------------

### extract_embeddings method implementation

Source: https://maartengr.github.io/KeyBERT/api/keybert.html

Full implementation of the extract_embeddings method, including parameter handling, vectorizer setup, and embedding extraction.

```python
def extract_embeddings(
    self,
    docs: Union[str, List[str]],
    candidates: List[str] = None,
    keyphrase_ngram_range: Tuple[int, int] = (1, 1),
    stop_words: Union[str, List[str]] = "english",
    min_df: int = 1,
    vectorizer: CountVectorizer = None,
) -> Union[List[Tuple[str, float]], List[List[Tuple[str, float]]]]:
    """Extract document and word embeddings for the input documents and the
    generated candidate keywords/keyphrases respectively.

    Note that all potential keywords/keyphrases are not returned but only their
    word embeddings. This means that the values of `candidates`, `keyphrase_ngram_range`,
    `stop_words`, and `min_df` need to be the same between using `.extract_embeddings` and
    `.extract_keywords`.

    Arguments:
        docs: The document(s) for which to extract keywords/keyphrases
        candidates: Candidate keywords/keyphrases to use instead of extracting them from the document(s)
                    NOTE: This is not used if you passed a `vectorizer`.
        keyphrase_ngram_range: Length, in words, of the extracted keywords/keyphrases.
                               NOTE: This is not used if you passed a `vectorizer`.
        stop_words: Stopwords to remove from the document.
                    NOTE: This is not used if you passed a `vectorizer`.
        min_df: Minimum document frequency of a word across all documents
                if keywords for multiple documents need to be extracted.
                NOTE: This is not used if you passed a `vectorizer`.
        vectorizer: Pass in your own `CountVectorizer` from
                    `sklearn.feature_extraction.text.CountVectorizer`

    Returns:
        doc_embeddings: The embeddings of each document.
        word_embeddings: The embeddings of each potential keyword/keyphrase across
                         across the vocabulary of the set of input documents.
                         NOTE: The `word_embeddings` should be generated through
                         `.extract_embeddings` as the order of these embeddings depend
                         on the vectorizer that was used to generate its vocabulary.

    Usage:

    To generate the word and document embeddings from a set of documents:

    ```python
    from keybert import KeyBERT

    kw_model = KeyBERT()
    doc_embeddings, word_embeddings = kw_model.extract_embeddings(docs)
    ```

    You can then use these embeddings and pass them to `.extract_keywords` to speed up the tuning the model:

    ```python
    keywords = kw_model.extract_keywords(docs, doc_embeddings=doc_embeddings, word_embeddings=word_embeddings)
    ```
    """
    # Check for a single, empty document
    if isinstance(docs, str):
        if docs:
            docs = [docs]
        else:
            return []

    # Extract potential words using a vectorizer / tokenizer
    if vectorizer:
        count = vectorizer.fit(docs)
    else:
        try:
            count = CountVectorizer(
                ngram_range=keyphrase_ngram_range,
                stop_words=stop_words,
                min_df=min_df,
                vocabulary=candidates,
            ).fit(docs)
        except ValueError:
            return []

    # Scikit-Learn Deprecation: get_feature_names is deprecated in 1.0
    # and will be removed in 1.2. Please use get_feature_names_out instead.
    if version.parse(sklearn_version) >= version.parse("1.0.0"):
        words = count.get_feature_names_out()
    else:
        words = count.get_feature_names()

    doc_embeddings = self.model.embed(docs)
    word_embeddings = self.model.embed(words)

    return doc_embeddings, word_embeddings
```

--------------------------------

### Use Sentence Transformers model with KeyBERT

Source: https://maartengr.github.io/KeyBERT/guides/embeddings.html

Select any model from sentence-transformers and pass it to KeyBERT using the `model` parameter. The example uses 'all-MiniLM-L6-v2'.

```python
from keybert import KeyBERT
kw_model = KeyBERT(model="all-MiniLM-L6-v2")
```

--------------------------------

### KeyLLM.__init__

Source: https://maartengr.github.io/KeyBERT/api/keyllm.html

Initializes a KeyLLM instance with a Large Language Model (LLM) to be used for keyword extraction.

```APIDOC
## KeyLLM.__init__

### Description
Initializes the KeyLLM class with a Large Language Model (LLM) instance that will be used for keyword extraction.

### Method
`__init__`

### Signature
```python
def __init__(self, llm):
```

### Parameters
- **llm** - Required - The Large Language Model to use.

### Usage Example
```python
from keybert import KeyLLM
from keybert.llm import OpenAI

llm = OpenAI(client)
kw_model = KeyLLM(llm)
```
```

--------------------------------

### Extract keywords from multiple documents

Source: https://maartengr.github.io/KeyBERT/api/keybert.html

Usage example for extracting keywords from multiple documents, which is typically faster. Creates a KeyBERT model and calls extract_keywords with a list of documents.

```python
from keybert import KeyBERT

kw_model = KeyBERT()
keywords = kw_model.extract_keywords(docs)
```
Tokens:
Raw