llama-cpp-haystack 0.1.0__tar.gz

llama_cpp_haystack-0.1.0/.gitignore

@@ -0,0 +1,133 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+volumes/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEs
+.vscode

llama_cpp_haystack-0.1.0/LICENSE.txt

@@ -0,0 +1,73 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+     (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+     (b) You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+     (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+     (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+     You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

llama_cpp_haystack-0.1.0/PKG-INFO

@@ -0,0 +1,258 @@
+Metadata-Version: 2.1
+Name: llama-cpp-haystack
+Version: 0.1.0
+Summary: An integration between the llama.cpp LLM framework and Haystack
+Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp#readme
+Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
+Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp
+Author: Ashwin Mathur
+Author-email: deepset GmbH <info@deepset.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: haystack-ai
+Requires-Dist: llama-cpp-python
+Description-Content-Type: text/markdown
+
+# llama-cpp-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/llama-cpp.svg)](https://pypi.org/project/llama-cpp-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/llama-cpp.svg)](https://pypi.org/project/llama-cpp)
+
+-----
+
+Custom component for [Haystack](https://github.com/deepset-ai/haystack) (2.x) for running LLMs using the [Llama.cpp](https://github.com/ggerganov/llama.cpp) LLM framework. This implementation leverages the [Python Bindings for llama.cpp](https://github.com/abetlen/llama-cpp-python).
+
+**Table of Contents**
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Example](#example)
+- [License](#license)
+
+## Installation
+
+```bash
+pip install llama-cpp-haystack
+```
+
+The default install behaviour is to build `llama.cpp` for CPU only on Linux and Windows and use Metal on MacOS.
+
+To install using the other backends, first install [llama-cpp-python](https://github.com/abetlen/llama-cpp-python) using the instructions on their [installation documentation](https://github.com/abetlen/llama-cpp-python#installation) and then install [llama-cpp-haystack](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp).
+
+
+For example, to use `llama-cpp-haystack` with the cuBLAS backend:
+
+```bash
+export LLAMA_CUBLAS=1
+CMAKE_ARGS="-DLLAMA_CUBLAS=on" pip install llama-cpp-python
+pip install llama-cpp-haystack
+```
+
+## Usage
+
+You can utilize the [`LlamaCppGenerator`](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp/src/llama_cpp_haystack/generator.py) to load models quantized using llama.cpp (GGUF) for text generation.
+
+Information about the supported models and model parameters can be found on the llama.cpp [documentation](https://llama-cpp-python.readthedocs.io/en/latest).
+
+The GGUF versions of popular models can be downloaded from [HuggingFace](https://huggingface.co/models?library=gguf).
+
+### Passing additional model parameters
+
+The `model_path`, `n_ctx`, `n_batch` arguments have been exposed for convenience and can be directly passed to the Generator during initialization as keyword arguments.  
+
+The `model_kwargs` parameter can be used to pass additional arguments when initializing the model. In case of duplication, these kwargs override `model_path`, `n_ctx`, and `n_batch` init parameters.
+
+See Llama.cpp's [model documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.__init__) for more information on the available model arguments.
+
+For example, to offload the model to GPU during initialization:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf", 
+    n_ctx=512,
+    n_batch=128,
+    model_kwargs={"n_gpu_layers": -1}
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(prompt, generation_kwargs={"max_tokens": 128})
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+### Passing generation parameters
+
+The `generation_kwargs` parameter can be used to pass additional generation arguments like `max_tokens`, `temperature`, `top_k`, `top_p`, etc to the model during inference. 
+
+See Llama.cpp's [`create_completion` documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_completion) for more information on the available generation arguments.
+
+For example, to set the `max_tokens` and `temperature`:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf",
+    n_ctx=512,
+    n_batch=128,
+    generation_kwargs={"max_tokens": 128, "temperature": 0.1},
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(prompt)
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+The `generation_kwargs` can also be passed to the `run` method of the generator directly:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf",
+    n_ctx=512,
+    n_batch=128,
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(
+    prompt,
+    generation_kwargs={"max_tokens": 128, "temperature": 0.1},
+)
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+
+## Example
+
+Below is the example Retrieval Augmented Generation pipeline that uses the [Simple Wikipedia](https://huggingface.co/datasets/pszemraj/simple_wikipedia) Dataset from HuggingFace. You can find more examples in the [`examples`](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp/examples) folder.
+
+
+Load the dataset:
+
+```python
+# Install HuggingFace Datasets using "pip install datasets"
+from datasets import load_dataset
+from haystack import Document, Pipeline
+from haystack.components.builders.answer_builder import AnswerBuilder
+from haystack.components.builders.prompt_builder import PromptBuilder
+from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
+from haystack.components.retrievers import InMemoryEmbeddingRetriever
+from haystack.components.writers import DocumentWriter
+from haystack.document_stores import InMemoryDocumentStore
+
+# Import LlamaCppGenerator
+from llama_cpp_haystack import LlamaCppGenerator
+
+# Load first 100 rows of the Simple Wikipedia Dataset from HuggingFace
+dataset = load_dataset("pszemraj/simple_wikipedia", split="validation[:100]")
+
+docs = [
+    Document(
+        content=doc["text"],
+        meta={
+            "title": doc["title"],
+            "url": doc["url"],
+        },
+    )
+    for doc in dataset
+]
+```
+
+Index the documents to the `InMemoryDocumentStore` using the `SentenceTransformersDocumentEmbedder` and `DocumentWriter`:
+
+```python
+doc_store = InMemoryDocumentStore(embedding_similarity_function="cosine")
+doc_embedder = SentenceTransformersDocumentEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+# Indexing Pipeline
+indexing_pipeline = Pipeline()
+indexing_pipeline.add_component(instance=doc_embedder, name="DocEmbedder")
+indexing_pipeline.add_component(instance=DocumentWriter(document_store=doc_store), name="DocWriter")
+indexing_pipeline.connect(connect_from="DocEmbedder", connect_to="DocWriter")
+
+indexing_pipeline.run({"DocEmbedder": {"documents": docs}})
+```
+
+Create the Retrieval Augmented Generation (RAG) pipeline and add the `LlamaCppGenerator` to it:
+
+```python
+# Prompt Template for the https://huggingface.co/openchat/openchat-3.5-1210 LLM
+prompt_template = """GPT4 Correct User: Answer the question using the provided context.
+Question: {{question}}
+Context:
+{% for doc in documents %}
+    {{ doc.content }}
+{% endfor %}
+<|end_of_turn|>
+GPT4 Correct Assistant:
+"""
+
+rag_pipeline = Pipeline()
+
+text_embedder = SentenceTransformersTextEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+# Load the LLM using LlamaCppGenerator
+model_path = "openchat-3.5-1210.Q3_K_S.gguf"
+generator = LlamaCppGenerator(model_path=model_path, n_ctx=4096, n_batch=128)
+
+rag_pipeline.add_component(
+    instance=text_embedder,
+    name="text_embedder",
+)
+rag_pipeline.add_component(instance=InMemoryEmbeddingRetriever(document_store=doc_store, top_k=3), name="retriever")
+rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
+rag_pipeline.add_component(instance=generator, name="llm")
+rag_pipeline.add_component(instance=AnswerBuilder(), name="answer_builder")
+
+rag_pipeline.connect("text_embedder", "retriever")
+rag_pipeline.connect("retriever", "prompt_builder.documents")
+rag_pipeline.connect("prompt_builder", "llm")
+rag_pipeline.connect("llm.replies", "answer_builder.replies")
+rag_pipeline.connect("retriever", "answer_builder.documents")
+```
+
+Run the pipeline:
+
+```python
+question = "Which year did the Joker movie release?"
+result = rag_pipeline.run(
+    {
+        "text_embedder": {"text": question},
+        "prompt_builder": {"question": question},
+        "llm": {"generation_kwargs": {"max_tokens": 128, "temperature": 0.1}},
+        "answer_builder": {"query": question},
+    }
+)
+
+generated_answer = result["answer_builder"]["answers"][0]
+print(generated_answer.data)
+# The Joker movie was released on October 4, 2019.
+```
+
+## License
+
+`llama-cpp-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

llama_cpp_haystack-0.1.0/README.md

@@ -0,0 +1,233 @@
+# llama-cpp-haystack
+
+[![PyPI - Version](https://img.shields.io/pypi/v/llama-cpp.svg)](https://pypi.org/project/llama-cpp-haystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/llama-cpp.svg)](https://pypi.org/project/llama-cpp)
+
+-----
+
+Custom component for [Haystack](https://github.com/deepset-ai/haystack) (2.x) for running LLMs using the [Llama.cpp](https://github.com/ggerganov/llama.cpp) LLM framework. This implementation leverages the [Python Bindings for llama.cpp](https://github.com/abetlen/llama-cpp-python).
+
+**Table of Contents**
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [Example](#example)
+- [License](#license)
+
+## Installation
+
+```bash
+pip install llama-cpp-haystack
+```
+
+The default install behaviour is to build `llama.cpp` for CPU only on Linux and Windows and use Metal on MacOS.
+
+To install using the other backends, first install [llama-cpp-python](https://github.com/abetlen/llama-cpp-python) using the instructions on their [installation documentation](https://github.com/abetlen/llama-cpp-python#installation) and then install [llama-cpp-haystack](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp).
+
+
+For example, to use `llama-cpp-haystack` with the cuBLAS backend:
+
+```bash
+export LLAMA_CUBLAS=1
+CMAKE_ARGS="-DLLAMA_CUBLAS=on" pip install llama-cpp-python
+pip install llama-cpp-haystack
+```
+
+## Usage
+
+You can utilize the [`LlamaCppGenerator`](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp/src/llama_cpp_haystack/generator.py) to load models quantized using llama.cpp (GGUF) for text generation.
+
+Information about the supported models and model parameters can be found on the llama.cpp [documentation](https://llama-cpp-python.readthedocs.io/en/latest).
+
+The GGUF versions of popular models can be downloaded from [HuggingFace](https://huggingface.co/models?library=gguf).
+
+### Passing additional model parameters
+
+The `model_path`, `n_ctx`, `n_batch` arguments have been exposed for convenience and can be directly passed to the Generator during initialization as keyword arguments.  
+
+The `model_kwargs` parameter can be used to pass additional arguments when initializing the model. In case of duplication, these kwargs override `model_path`, `n_ctx`, and `n_batch` init parameters.
+
+See Llama.cpp's [model documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.__init__) for more information on the available model arguments.
+
+For example, to offload the model to GPU during initialization:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf", 
+    n_ctx=512,
+    n_batch=128,
+    model_kwargs={"n_gpu_layers": -1}
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(prompt, generation_kwargs={"max_tokens": 128})
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+### Passing generation parameters
+
+The `generation_kwargs` parameter can be used to pass additional generation arguments like `max_tokens`, `temperature`, `top_k`, `top_p`, etc to the model during inference. 
+
+See Llama.cpp's [`create_completion` documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_completion) for more information on the available generation arguments.
+
+For example, to set the `max_tokens` and `temperature`:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf",
+    n_ctx=512,
+    n_batch=128,
+    generation_kwargs={"max_tokens": 128, "temperature": 0.1},
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(prompt)
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+The `generation_kwargs` can also be passed to the `run` method of the generator directly:
+
+```python
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(
+    model_path="/content/openchat-3.5-1210.Q3_K_S.gguf",
+    n_ctx=512,
+    n_batch=128,
+)
+generator.warm_up()
+
+input = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {input} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(
+    prompt,
+    generation_kwargs={"max_tokens": 128, "temperature": 0.1},
+)
+generated_text = result["replies"][0]
+
+print(generated_text)
+```
+
+## Example
+
+Below is the example Retrieval Augmented Generation pipeline that uses the [Simple Wikipedia](https://huggingface.co/datasets/pszemraj/simple_wikipedia) Dataset from HuggingFace. You can find more examples in the [`examples`](https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp/examples) folder.
+
+
+Load the dataset:
+
+```python
+# Install HuggingFace Datasets using "pip install datasets"
+from datasets import load_dataset
+from haystack import Document, Pipeline
+from haystack.components.builders.answer_builder import AnswerBuilder
+from haystack.components.builders.prompt_builder import PromptBuilder
+from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
+from haystack.components.retrievers import InMemoryEmbeddingRetriever
+from haystack.components.writers import DocumentWriter
+from haystack.document_stores import InMemoryDocumentStore
+
+# Import LlamaCppGenerator
+from llama_cpp_haystack import LlamaCppGenerator
+
+# Load first 100 rows of the Simple Wikipedia Dataset from HuggingFace
+dataset = load_dataset("pszemraj/simple_wikipedia", split="validation[:100]")
+
+docs = [
+    Document(
+        content=doc["text"],
+        meta={
+            "title": doc["title"],
+            "url": doc["url"],
+        },
+    )
+    for doc in dataset
+]
+```
+
+Index the documents to the `InMemoryDocumentStore` using the `SentenceTransformersDocumentEmbedder` and `DocumentWriter`:
+
+```python
+doc_store = InMemoryDocumentStore(embedding_similarity_function="cosine")
+doc_embedder = SentenceTransformersDocumentEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+# Indexing Pipeline
+indexing_pipeline = Pipeline()
+indexing_pipeline.add_component(instance=doc_embedder, name="DocEmbedder")
+indexing_pipeline.add_component(instance=DocumentWriter(document_store=doc_store), name="DocWriter")
+indexing_pipeline.connect(connect_from="DocEmbedder", connect_to="DocWriter")
+
+indexing_pipeline.run({"DocEmbedder": {"documents": docs}})
+```
+
+Create the Retrieval Augmented Generation (RAG) pipeline and add the `LlamaCppGenerator` to it:
+
+```python
+# Prompt Template for the https://huggingface.co/openchat/openchat-3.5-1210 LLM
+prompt_template = """GPT4 Correct User: Answer the question using the provided context.
+Question: {{question}}
+Context:
+{% for doc in documents %}
+    {{ doc.content }}
+{% endfor %}
+<|end_of_turn|>
+GPT4 Correct Assistant:
+"""
+
+rag_pipeline = Pipeline()
+
+text_embedder = SentenceTransformersTextEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+# Load the LLM using LlamaCppGenerator
+model_path = "openchat-3.5-1210.Q3_K_S.gguf"
+generator = LlamaCppGenerator(model_path=model_path, n_ctx=4096, n_batch=128)
+
+rag_pipeline.add_component(
+    instance=text_embedder,
+    name="text_embedder",
+)
+rag_pipeline.add_component(instance=InMemoryEmbeddingRetriever(document_store=doc_store, top_k=3), name="retriever")
+rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
+rag_pipeline.add_component(instance=generator, name="llm")
+rag_pipeline.add_component(instance=AnswerBuilder(), name="answer_builder")
+
+rag_pipeline.connect("text_embedder", "retriever")
+rag_pipeline.connect("retriever", "prompt_builder.documents")
+rag_pipeline.connect("prompt_builder", "llm")
+rag_pipeline.connect("llm.replies", "answer_builder.replies")
+rag_pipeline.connect("retriever", "answer_builder.documents")
+```
+
+Run the pipeline:
+
+```python
+question = "Which year did the Joker movie release?"
+result = rag_pipeline.run(
+    {
+        "text_embedder": {"text": question},
+        "prompt_builder": {"question": question},
+        "llm": {"generation_kwargs": {"max_tokens": 128, "temperature": 0.1}},
+        "answer_builder": {"query": question},
+    }
+)
+
+generated_answer = result["answer_builder"]["answers"][0]
+print(generated_answer.data)
+# The Joker movie was released on October 4, 2019.
+```
+
+## License
+
+`llama-cpp-haystack` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.

llama_cpp_haystack-0.1.0/examples/llama_cpp_generator_example.py

@@ -0,0 +1,12 @@
+from llama_cpp_haystack import LlamaCppGenerator
+
+generator = LlamaCppGenerator(model_path="openchat-3.5-1210.Q3_K_S.gguf", n_ctx=512, n_batch=128)
+generator.warm_up()
+
+question = "Who is the best American actor?"
+prompt = f"GPT4 Correct User: {question} <|end_of_turn|> GPT4 Correct Assistant:"
+
+result = generator.run(prompt, generation_kwargs={"max_tokens": 128})
+generated_text = result["replies"][0]
+
+print(generated_text)

llama_cpp_haystack-0.1.0/examples/rag_pipeline_example.py

@@ -0,0 +1,85 @@
+from datasets import load_dataset
+from haystack import Document, Pipeline
+from haystack.components.builders.answer_builder import AnswerBuilder
+from haystack.components.builders.prompt_builder import PromptBuilder
+from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
+from haystack.components.retrievers import InMemoryEmbeddingRetriever
+from haystack.components.writers import DocumentWriter
+from haystack.document_stores import InMemoryDocumentStore
+
+from llama_cpp_haystack import LlamaCppGenerator
+
+# Load first 100 rows of the Simple Wikipedia Dataset from HuggingFace
+dataset = load_dataset("pszemraj/simple_wikipedia", split="validation[:100]")
+
+docs = [
+    Document(
+        content=doc["text"],
+        meta={
+            "title": doc["title"],
+            "url": doc["url"],
+        },
+    )
+    for doc in dataset
+]
+
+doc_store = InMemoryDocumentStore(embedding_similarity_function="cosine")
+doc_embedder = SentenceTransformersDocumentEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+
+# Indexing Pipeline
+indexing_pipeline = Pipeline()
+indexing_pipeline.add_component(instance=doc_embedder, name="DocEmbedder")
+indexing_pipeline.add_component(instance=DocumentWriter(document_store=doc_store), name="DocWriter")
+indexing_pipeline.connect(connect_from="DocEmbedder", connect_to="DocWriter")
+
+indexing_pipeline.run({"DocEmbedder": {"documents": docs}})
+
+
+# RAG Pipeline
+prompt_template = """GPT4 Correct User: Answer the question using the provided context.
+Question: {{question}}
+Context:
+{% for doc in documents %}
+    {{ doc.content }}
+{% endfor %}
+<|end_of_turn|>
+GPT4 Correct Assistant:
+"""
+rag_pipeline = Pipeline()
+
+text_embedder = SentenceTransformersTextEmbedder(model_name_or_path="sentence-transformers/all-MiniLM-L6-v2")
+
+model_path = "openchat-3.5-1210.Q3_K_S.gguf"
+generator = LlamaCppGenerator(model_path=model_path, n_ctx=4096, n_batch=128)
+
+rag_pipeline.add_component(
+    instance=text_embedder,
+    name="text_embedder",
+)
+rag_pipeline.add_component(instance=InMemoryEmbeddingRetriever(document_store=doc_store, top_k=3), name="retriever")
+rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
+rag_pipeline.add_component(instance=generator, name="llm")
+rag_pipeline.add_component(instance=AnswerBuilder(), name="answer_builder")
+
+rag_pipeline.connect("text_embedder", "retriever")
+rag_pipeline.connect("retriever", "prompt_builder.documents")
+rag_pipeline.connect("prompt_builder", "llm")
+rag_pipeline.connect("llm.replies", "answer_builder.replies")
+rag_pipeline.connect("retriever", "answer_builder.documents")
+
+
+# Run Pipeline
+question = "Which year did the Joker movie release?"
+result = rag_pipeline.run(
+    {
+        "text_embedder": {"text": question},
+        "prompt_builder": {"question": question},
+        "llm": {"generation_kwargs": {"max_tokens": 128, "temperature": 0.1}},
+        "answer_builder": {"query": question},
+    }
+)
+
+generated_answer = result["answer_builder"]["answers"][0]
+print(generated_answer.data)
+# The Joker movie was released on October 4, 2019.

llama_cpp_haystack-0.1.0/pyproject.toml

@@ -0,0 +1,185 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "llama-cpp-haystack"
+dynamic = ["version"]
+description = 'An integration between the llama.cpp LLM framework and Haystack'
+readme = "README.md"
+requires-python = ">=3.8"
+license = "Apache-2.0"
+keywords = []
+authors = [
+    { name = "deepset GmbH", email = "info@deepset.ai" },
+    { name = "Ashwin Mathur", email = "" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "haystack-ai",
+  "llama-cpp-python"
+]
+
+[project.urls]
+Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp#readme"
+Issues = "https://github.com/deepset-ai/haystack-core-integrations/issues"
+Source = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama_cpp"
+
+[tool.hatch.version]
+source = "vcs"
+tag-pattern = 'integrations\/llama_cpp-v(?P<version>.*)'
+
+[tool.hatch.version.raw-options]
+root = "../.."
+git_describe_command = 'git describe --tags --match="integrations/llama_cpp-v[0-9]*"'
+
+[tool.hatch.envs.default]
+dependencies = [
+    "coverage[toml]>=6.5",
+    "pytest",
+]
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+    "- coverage combine",
+    "coverage report",
+]
+cov = [
+    "test-cov",
+    "cov-report",
+]
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
+
+
+[tool.hatch.envs.lint]
+detached = true
+dependencies = [
+    "black>=23.1.0",
+    "mypy>=1.0.0",
+    "ruff>=0.0.243",
+]
+
+[tool.hatch.envs.lint.scripts]
+typing = "mypy --install-types --non-interactive {args:src/llama_cpp_haystack tests}"
+style = [
+    "ruff {args:.}",
+    "black --check --diff {args:.}",
+]
+fmt = [
+    "black {args:.}",
+    "ruff --fix {args:.}",
+    "style",
+]
+all = [
+    "style",
+    "typing",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.ruff.isort]
+known-first-party = ["llama_cpp_haystack"]
+
+[tool.black]
+target-version = ["py37"]
+line-length = 120
+skip-string-normalization = true
+
+[tool.ruff]
+target-version = "py37"
+line-length = 120
+select = [
+    "A",
+    "ARG",
+    "B",
+    "C",
+    "DTZ",
+    "E",
+    "EM",
+    "F",
+    "I",
+    "ICN",
+    "ISC",
+    "N",
+    "PLC",
+    "PLE",
+    "PLR",
+    "PLW",
+    "Q",
+    "RUF",
+    "S",
+    "T",
+    "TID",
+    "UP",
+    "W",
+    "YTT",
+]
+ignore = [
+    # Allow non-abstract empty methods in abstract base classes
+    "B027",
+    # Ignore checks for possible passwords
+    "S105", "S106", "S107",
+    # Ignore complexity
+    "C901", "PLR0911", "PLR0912", "PLR0913", "PLR0915",
+]
+unfixable = [
+    # Don't touch unused imports
+    "F401",
+]
+
+[tool.ruff.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**/*" = ["PLR2004", "S101", "TID252"]
+# Examples can print their output
+"examples/**" = ["T201"]
+"tests/**" = ["T201"]
+
+[tool.coverage.run]
+source_pkgs = ["llama_cpp_haystack", "tests"]
+branch = true
+parallel = true
+
+
+[tool.coverage.paths]
+ollama_haystack = ["src/llama_cpp_haystack", "*/llama-cpp-haystack/src/llama_cpp_haystack"]
+tests = ["tests", "*/llama-cpp-haystack/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "no cov",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+
+[tool.pytest.ini_options]
+markers = [
+    "integration: marks tests as slow (deselect with '-m \"not integration\"')",
+]
+addopts = [
+    "--import-mode=importlib",
+]
+
+[[tool.mypy.overrides]]
+module = [
+    "haystack.*",
+    "pytest.*",
+    "llama_cpp.*"
+]
+ignore_missing_imports = true

llama_cpp_haystack-0.1.0/src/llama_cpp_haystack/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from llama_cpp_haystack.generator import LlamaCppGenerator
+
+__all__ = ["LlamaCppGenerator"]

llama_cpp_haystack-0.1.0/src/llama_cpp_haystack/generator.py

@@ -0,0 +1,98 @@
+import logging
+from typing import Any, Dict, List, Optional
+
+from haystack import component
+from llama_cpp import Llama
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class LlamaCppGenerator:
+    """
+    Generator for using a model with Llama.cpp.
+    This component provides an interface to generate text using a quantized model (GGUF) using llama.cpp.
+
+    Usage example:
+    ```python
+    from llama_cpp_haystack import LlamaCppGenerator
+    generator = LlamaCppGenerator(model_path="zephyr-7b-beta.Q4_0.gguf", n_ctx=2048, n_batch=512)
+
+    print(generator.run("Who is the best American actor?", generation_kwargs={"max_tokens": 128}))
+    # {'replies': ['John Cusack'], 'meta': [{"object": "text_completion", ...}]}
+    ```
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        n_ctx: Optional[int] = 0,
+        n_batch: Optional[int] = 512,
+        model_kwargs: Optional[Dict[str, Any]] = None,
+        generation_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        :param model_path: The path of a quantized model for text generation,
+            for example, "zephyr-7b-beta.Q4_0.gguf".
+            If the model_path is also specified in the `model_kwargs`, this parameter will be ignored.
+        :param n_ctx: The number of tokens in the context. When set to 0, the context will be taken from the model.
+            If the n_ctx is also specified in the `model_kwargs`, this parameter will be ignored.
+        :param n_batch: Prompt processing maximum batch size. Defaults to 512.
+            If the n_batch is also specified in the `model_kwargs`, this parameter will be ignored.
+        :param model_kwargs: Dictionary containing keyword arguments used to initialize the LLM for text generation.
+            These keyword arguments provide fine-grained control over the model loading.
+            In case of duplication, these kwargs override `model_path`, `n_ctx`, and `n_batch` init parameters.
+            See Llama.cpp's [documentation](https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.__init__)
+            for more information on the available kwargs.
+        :param generation_kwargs:  A dictionary containing keyword arguments to customize text generation.
+            Some examples: `max_tokens`, `temperature`, `top_k`, `top_p`,...
+            See Llama.cpp's  documentation for more information:
+                https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_completion
+        """
+
+        model_kwargs = model_kwargs or {}
+        generation_kwargs = generation_kwargs or {}
+
+        # check if the huggingface_pipeline_kwargs contain the essential parameters
+        # otherwise, populate them with values from init parameters
+        model_kwargs.setdefault("model_path", model_path)
+        model_kwargs.setdefault("n_ctx", n_ctx)
+        model_kwargs.setdefault("n_batch", n_batch)
+
+        self.model_path = model_path
+        self.n_ctx = n_ctx
+        self.n_batch = n_batch
+        self.model_kwargs = model_kwargs
+        self.generation_kwargs = generation_kwargs
+        self.model = None
+
+    def warm_up(self):
+        if self.model is None:
+            self.model = Llama(**self.model_kwargs)
+
+    @component.output_types(replies=List[str], meta=List[Dict[str, Any]])
+    def run(self, prompt: str, generation_kwargs: Optional[Dict[str, Any]] = None):
+        """
+        Run the text generation model on the given prompt.
+
+        :param prompt: A string representing the prompt.
+        :param generation_kwargs: A dictionary containing keyword arguments to customize text generation.
+            Some examples: `max_tokens`, `temperature`, `top_k`, `top_p`,...
+            See Llama.cpp's  documentation for more information:
+                https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_completion
+        :return: A dictionary of the returned responses and metadata.
+        """
+        if self.model is None:
+            error_msg = "The model has not been loaded. Please call warm_up() before running."
+            raise RuntimeError(error_msg)
+
+        if not prompt:
+            return {"replies": []}
+
+        # merge generation kwargs from init method with those from run method
+        updated_generation_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}
+
+        output = self.model.create_completion(prompt=prompt, **updated_generation_kwargs)
+        replies = [output["choices"][0]["text"]]
+
+        return {"replies": replies, "meta": [output]}

llama_cpp_haystack-0.1.0/tests/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0

llama_cpp_haystack-0.1.0/tests/models/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

llama_cpp_haystack-0.1.0/tests/test_generator.py

@@ -0,0 +1,233 @@
+import os
+import urllib.request
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+from haystack import Document, Pipeline
+from haystack.components.builders.answer_builder import AnswerBuilder
+from haystack.components.builders.prompt_builder import PromptBuilder
+from haystack.components.retrievers import InMemoryBM25Retriever
+from haystack.document_stores import InMemoryDocumentStore
+
+from llama_cpp_haystack import LlamaCppGenerator
+
+
+@pytest.fixture
+def model_path():
+    return Path(__file__).parent / "models"
+
+
+def download_file(file_link, filename, capsys):
+    # Checks if the file already exists before downloading
+    if not os.path.isfile(filename):
+        urllib.request.urlretrieve(file_link, filename)  # noqa: S310
+        with capsys.disabled():
+            print("\nModel file downloaded successfully.")
+    else:
+        with capsys.disabled():
+            print("\nModel file already exists.")
+
+
+class TestLlamaCppGenerator:
+    @pytest.fixture
+    def generator(self, model_path, capsys):
+        ggml_model_path = (
+            "https://huggingface.co/TheBloke/openchat-3.5-1210-GGUF/resolve/main/openchat-3.5-1210.Q3_K_S.gguf"
+        )
+        filename = "openchat-3.5-1210.Q3_K_S.gguf"
+
+        # Download GGUF model from HuggingFace
+        download_file(ggml_model_path, str(model_path / filename), capsys)
+
+        model_path = str(model_path / filename)
+        generator = LlamaCppGenerator(model_path=model_path, n_ctx=128, n_batch=128)
+        generator.warm_up()
+        return generator
+
+    @pytest.fixture
+    def generator_mock(self):
+        mock_model = MagicMock()
+        generator = LlamaCppGenerator(model_path="test_model.gguf", n_ctx=2048, n_batch=512)
+        generator.model = mock_model
+        return generator, mock_model
+
+    def test_default_init(self):
+        """
+        Test default initialization parameters.
+        """
+        generator = LlamaCppGenerator(model_path="test_model.gguf")
+
+        assert generator.model_path == "test_model.gguf"
+        assert generator.n_ctx == 0
+        assert generator.n_batch == 512
+        assert generator.model_kwargs == {"model_path": "test_model.gguf", "n_ctx": 0, "n_batch": 512}
+        assert generator.generation_kwargs == {}
+
+    def test_custom_init(self):
+        """
+        Test custom initialization parameters.
+        """
+        generator = LlamaCppGenerator(
+            model_path="test_model.gguf",
+            n_ctx=2048,
+            n_batch=512,
+        )
+
+        assert generator.model_path == "test_model.gguf"
+        assert generator.n_ctx == 2048
+        assert generator.n_batch == 512
+        assert generator.model_kwargs == {"model_path": "test_model.gguf", "n_ctx": 2048, "n_batch": 512}
+        assert generator.generation_kwargs == {}
+
+    def test_ignores_model_path_if_specified_in_model_kwargs(self):
+        """
+        Test that model_path is ignored if already specified in model_kwargs.
+        """
+        generator = LlamaCppGenerator(
+            model_path="test_model.gguf",
+            n_ctx=512,
+            n_batch=512,
+            model_kwargs={"model_path": "other_model.gguf"},
+        )
+        assert generator.model_kwargs["model_path"] == "other_model.gguf"
+
+    def test_ignores_n_ctx_if_specified_in_model_kwargs(self):
+        """
+        Test that n_ctx is ignored if already specified in model_kwargs.
+        """
+        generator = LlamaCppGenerator(
+            model_path="test_model.gguf", n_ctx=512, n_batch=512, model_kwargs={"n_ctx": 1024}
+        )
+        assert generator.model_kwargs["n_ctx"] == 1024
+
+    def test_ignores_n_batch_if_specified_in_model_kwargs(self):
+        """
+        Test that n_batch is ignored if already specified in model_kwargs.
+        """
+        generator = LlamaCppGenerator(
+            model_path="test_model.gguf", n_ctx=512, n_batch=512, model_kwargs={"n_batch": 1024}
+        )
+        assert generator.model_kwargs["n_batch"] == 1024
+
+    def test_raises_error_without_warm_up(self):
+        """
+        Test that the generator raises an error if warm_up() is not called before running.
+        """
+        generator = LlamaCppGenerator(model_path="test_model.gguf", n_ctx=512, n_batch=512)
+        with pytest.raises(RuntimeError):
+            generator.run("What is the capital of China?")
+
+    def test_run_with_empty_prompt(self, generator_mock):
+        """
+        Test that an empty prompt returns an empty list of replies.
+        """
+        generator, _ = generator_mock
+        result = generator.run("")
+        assert result["replies"] == []
+
+    def test_run_with_valid_prompt(self, generator_mock):
+        """
+        Test that a valid prompt returns a list of replies.
+        """
+        generator, mock_model = generator_mock
+        mock_output = {
+            "choices": [{"text": "Generated text"}],
+            "metadata": {"other_info": "Some metadata"},
+        }
+        mock_model.create_completion.return_value = mock_output
+        result = generator.run("Test prompt")
+        assert result["replies"] == ["Generated text"]
+        assert result["meta"] == [mock_output]
+
+    def test_run_with_generation_kwargs(self, generator_mock):
+        """
+        Test that a valid prompt and generation kwargs returns a list of replies.
+        """
+        generator, mock_model = generator_mock
+        mock_output = {
+            "choices": [{"text": "Generated text"}],
+            "metadata": {"other_info": "Some metadata"},
+        }
+        mock_model.create_completion.return_value = mock_output
+        generation_kwargs = {"max_tokens": 128}
+        result = generator.run("Test prompt", generation_kwargs)
+        assert result["replies"] == ["Generated text"]
+        assert result["meta"] == [mock_output]
+
+    @pytest.mark.integration
+    def test_run(self, generator):
+        """
+        Test that a valid prompt returns a list of replies.
+        """
+        questions_and_answers = [
+            ("What's the capital of France?", "Paris"),
+            ("What is the capital of Canada?", "Ottawa"),
+            ("What is the capital of Ghana?", "Accra"),
+        ]
+
+        for question, answer in questions_and_answers:
+            prompt = f"GPT4 Correct User: Answer in a single word. {question} <|end_of_turn|>\n GPT4 Correct Assistant:"
+            result = generator.run(prompt)
+
+            assert "replies" in result
+            assert isinstance(result["replies"], list)
+            assert len(result["replies"]) > 0
+            assert answer.lower() in result["replies"][0].lower().strip()
+
+    @pytest.mark.integration
+    def test_run_rag_pipeline(self, generator):
+        """
+        Test that a valid prompt returns a list of replies.
+        """
+        prompt_template = """GPT4 Correct User: Answer the question in a single word. {{question}}
+        Context:
+        {% for doc in documents %}
+            {{ doc.content }}
+        {% endfor %}
+        <|end_of_turn|>
+        GPT4 Correct Assistant:
+        """
+        rag_pipeline = Pipeline()
+        rag_pipeline.add_component(
+            instance=InMemoryBM25Retriever(document_store=InMemoryDocumentStore(), top_k=1), name="retriever"
+        )
+        rag_pipeline.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
+        rag_pipeline.add_component(instance=generator, name="llm")
+        rag_pipeline.add_component(instance=AnswerBuilder(), name="answer_builder")
+        rag_pipeline.connect("retriever", "prompt_builder.documents")
+        rag_pipeline.connect("prompt_builder", "llm")
+        rag_pipeline.connect("llm.replies", "answer_builder.replies")
+        rag_pipeline.connect("retriever", "answer_builder.documents")
+
+        # Populate the document store
+        documents = [
+            Document(content="The capital of France is Paris."),
+            Document(content="The capital of Canada is Ottawa."),
+            Document(content="The capital of Ghana is Accra."),
+        ]
+        rag_pipeline.get_component("retriever").document_store.write_documents(documents)
+
+        # Query and assert
+        questions_and_answers = [
+            ("What's the capital of France?", "Paris"),
+            ("What is the capital of Canada?", "Ottawa"),
+            ("What is the capital of Ghana?", "Accra"),
+        ]
+
+        for question, answer in questions_and_answers:
+            result = rag_pipeline.run(
+                {
+                    "retriever": {"query": question},
+                    "prompt_builder": {"question": question},
+                    "llm": {"generation_kwargs": {"temperature": 0.1}},
+                    "answer_builder": {"query": question},
+                }
+            )
+
+            assert len(result["answer_builder"]["answers"]) == 1
+            generated_answer = result["answer_builder"]["answers"][0]
+            assert answer.lower() in generated_answer.data.lower()
+            assert generated_answer.query == question
+            assert hasattr(generated_answer, "documents")
+            assert hasattr(generated_answer, "meta")