llama cpp python
v0.3.2
llama.cpp 
Liaisons Python simples pour la bibliothèque llama.cpp de @ggerganov . Ce forfait fournit :
ctypes .La documentation est disponible sur https://llama-cpp-python.readthedocs.io/en/latest.
Exigences:
Pour installer le package, exécutez :
pip install llama-cpp-python Cela construira également llama.cpp à partir des sources et l'installera avec ce package python.
Si cela échoue, ajoutez --verbose à l' pip install consultez le journal de construction complet de cmake.
Roue pré-construite (nouvelle)
Il est également possible d'installer une roue pré-construite avec un support CPU de base.
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu llama.cpp prend en charge un certain nombre de backends d'accélération matérielle pour accélérer l'inférence ainsi que des options spécifiques au backend. Voir le fichier README llama.cpp pour une liste complète.
Toutes les options de construction cmake llama.cpp peuvent être définies via la variable d'environnement CMAKE_ARGS ou via l'indicateur cli --config-settings / -C lors de l'installation.
# Linux and Mac
CMAKE_ARGS= " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS "
pip install llama-cpp-python # Windows
$ env: CMAKE_ARGS = " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS "
pip install llama - cpp - python Ils peuvent également être définis via la commande pip install -C / --config-settings et enregistrés dans un fichier requirements.txt :
pip install --upgrade pip # ensure pip is up to date
pip install llama-cpp-python
-C cmake.args= " -DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS " # requirements.txt
llama-cpp-python -C cmake.args="-DGGML_BLAS=ON;-DGGML_BLAS_VENDOR=OpenBLAS"Vous trouverez ci-dessous quelques backends courants, leurs commandes de construction et toutes les variables d'environnement supplémentaires requises.
Pour installer avec OpenBLAS, définissez les variables d'environnement GGML_BLAS et GGML_BLAS_VENDOR avant d'installer :
CMAKE_ARGS= " -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS " pip install llama-cpp-python Pour installer avec le support CUDA, définissez la variable d'environnement GGML_CUDA=on avant d'installer :
CMAKE_ARGS= " -DGGML_CUDA=on " pip install llama-cpp-pythonRoue pré-construite (nouvelle)
Il est également possible d'installer une roue pré-construite avec le support CUDA. Tant que votre système répond à certaines exigences :
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/ < cuda-version > Où <cuda-version> est l'un des éléments suivants :
cu121 : CUDA 12.1cu122 : CUDA 12.2cu123 : CUDA 12.3cu124 : CUDA 12.4cu125 : CUDA 12,5Par exemple, pour installer la roue CUDA 12.1 :
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu121 Pour installer avec Metal (MPS), définissez la variable d'environnement GGML_METAL=on avant d'installer :
CMAKE_ARGS= " -DGGML_METAL=on " pip install llama-cpp-pythonRoue pré-construite (nouvelle)
Il est également possible d'installer une roue préfabriquée avec support métallique. Tant que votre système répond à certaines exigences :
pip install llama-cpp-python
--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/metal Pour installer avec la prise en charge hipBLAS / ROCm pour les cartes AMD, définissez la variable d'environnement GGML_HIPBLAS=on avant l'installation :
CMAKE_ARGS= " -DGGML_HIPBLAS=on " pip install llama-cpp-python Pour installer avec le support Vulkan, définissez la variable d'environnement GGML_VULKAN=on avant d'installer :
CMAKE_ARGS= " -DGGML_VULKAN=on " pip install llama-cpp-python Pour installer avec la prise en charge de SYCL, définissez la variable d'environnement GGML_SYCL=on avant d'installer :
source /opt/intel/oneapi/setvars.sh
CMAKE_ARGS= " -DGGML_SYCL=on -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx " pip install llama-cpp-python Pour installer avec la prise en charge RPC, définissez la variable d'environnement GGML_RPC=on avant l'installation :
source /opt/intel/oneapi/setvars.sh
CMAKE_ARGS= " -DGGML_RPC=on " pip install llama-cpp-python Si vous rencontrez des problèmes où il se plaint, il ne trouve pas 'nmake' '?' ou CMAKE_C_COMPILER, vous pouvez extraire w64devkit comme mentionné dans le dépôt llama.cpp et les ajouter manuellement à CMAKE_ARGS avant d'exécuter pip install :
$env:CMAKE_GENERATOR = "MinGW Makefiles"
$env:CMAKE_ARGS = "-DGGML_OPENBLAS=on -DCMAKE_C_COMPILER=C: /w64devkit/bin/gcc.exe -DCMAKE_CXX_COMPILER=C: /w64devkit/bin/g++.exe" Consultez les instructions ci-dessus et définissez CMAKE_ARGS sur le backend BLAS que vous souhaitez utiliser.
Une documentation détaillée sur l'installation du GPU MacOS Metal est disponible sur docs/install/macos.md
Remarque : Si vous utilisez un Mac Apple Silicon (M1), assurez-vous d'avoir installé une version de Python prenant en charge l'architecture arm64. Par exemple:
wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.shSinon, lors de l'installation, la version llama.cpp x86 sera construite, qui sera 10 fois plus lente sur Mac Apple Silicon (M1).
Essayez d'installer avec
CMAKE_ARGS= " -DCMAKE_OSX_ARCHITECTURES=arm64 -DCMAKE_APPLE_SILICON_PROCESSOR=arm64 -DGGML_METAL=on " pip install --upgrade --verbose --force-reinstall --no-cache-dir llama-cpp-python Pour mettre à niveau et reconstruire llama-cpp-python ajoutez les indicateurs --upgrade --force-reinstall --no-cache-dir à la commande pip install pour garantir que le package est reconstruit à partir de la source.
Référence API
L'API de haut niveau fournit une interface gérée simple via la classe Llama .
Vous trouverez ci-dessous un court exemple montrant comment utiliser l'API de haut niveau pour compléter un texte de base :
from llama_cpp import Llama
llm = Llama (
model_path = "./models/7B/llama-model.gguf" ,
# n_gpu_layers=-1, # Uncomment to use GPU acceleration
# seed=1337, # Uncomment to set a specific seed
# n_ctx=2048, # Uncomment to increase the context window
)
output = llm (
"Q: Name the planets in the solar system? A: " , # Prompt
max_tokens = 32 , # Generate up to 32 tokens, set to None to generate up to the end of the context window
stop = [ "Q:" , " n " ], # Stop generating just before the model would generate a new question
echo = True # Echo the prompt back in the output
) # Generate a completion, can also call create_completion
print ( output ) Par défaut, llama-cpp-python génère des complétions dans un format compatible OpenAI :
{
"id" : "cmpl-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" ,
"object" : "text_completion" ,
"created" : 1679561337 ,
"model" : "./models/7B/llama-model.gguf" ,
"choices" : [
{
"text" : "Q: Name the planets in the solar system? A: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune and Pluto." ,
"index" : 0 ,
"logprobs" : None ,
"finish_reason" : "stop"
}
],
"usage" : {
"prompt_tokens" : 14 ,
"completion_tokens" : 28 ,
"total_tokens" : 42
}
} La complétion de texte est disponible via les méthodes __call__ et create_completion de la classe Llama .
Vous pouvez télécharger des modèles Llama au format gguf directement depuis Hugging Face en utilisant la méthode from_pretrained . Vous devrez installer le package huggingface-hub pour utiliser cette fonctionnalité ( pip install huggingface-hub ).
llm = Llama . from_pretrained (
repo_id = "Qwen/Qwen2-0.5B-Instruct-GGUF" ,
filename = "*q8_0.gguf" ,
verbose = False
) Par défaut, from_pretrained téléchargera le modèle dans le répertoire de cache Huggingface, vous pourrez ensuite gérer les fichiers de modèle installés avec l'outil huggingface-cli .
L'API de haut niveau fournit également une interface simple pour la réalisation de discussions.
L'achèvement du chat nécessite que le modèle sache comment formater les messages en une seule invite. La classe Llama fait cela en utilisant des formats de discussion préenregistrés (c'est-à-dire chatml , llama-2 , gemma , etc.) ou en fournissant un objet de gestionnaire de discussion personnalisé.
Le modèle formatera les messages en une seule invite en utilisant l'ordre de priorité suivant :
chat_handler s'il est fournichat_format s'il est fournitokenizer.chat_template à partir des métadonnées du modèle gguf (devrait fonctionner pour la plupart des nouveaux modèles, les anciens modèles peuvent ne pas l'avoir)llama-2 Définissez verbose=True pour voir le format de discussion sélectionné.
from llama_cpp import Llama
llm = Llama (
model_path = "path/to/llama-2/llama-model.gguf" ,
chat_format = "llama-2"
)
llm . create_chat_completion (
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : "Describe this image in detail please."
}
]
) La complétion du chat est disponible via la méthode create_chat_completion de la classe Llama .
Pour la compatibilité OpenAI API v1, vous utilisez la méthode create_chat_completion_openai_v1 qui renverra des modèles pydantiques au lieu de dicts.
Pour limiter les réponses de discussion à un JSON valide uniquement ou à un schéma JSON spécifique, utilisez l'argument response_format dans create_chat_completion .
L'exemple suivant limitera la réponse aux chaînes JSON valides uniquement.
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/model.gguf" , chat_format = "chatml" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "You are a helpful assistant that outputs in JSON." ,
},
{ "role" : "user" , "content" : "Who won the world series in 2020" },
],
response_format = {
"type" : "json_object" ,
},
temperature = 0.7 ,
) Pour contraindre davantage la réponse à un schéma JSON spécifique, ajoutez le schéma à la propriété schema de l'argument response_format .
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/model.gguf" , chat_format = "chatml" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "You are a helpful assistant that outputs in JSON." ,
},
{ "role" : "user" , "content" : "Who won the world series in 2020" },
],
response_format = {
"type" : "json_object" ,
"schema" : {
"type" : "object" ,
"properties" : { "team_name" : { "type" : "string" }},
"required" : [ "team_name" ],
},
},
temperature = 0.7 ,
) L'API de haut niveau prend en charge les appels de fonctions et d'outils compatibles OpenAI. Ceci est possible grâce au format de discussion des modèles functionary pré-entraînés ou via le format de discussion générique chatml-function-calling .
from llama_cpp import Llama
llm = Llama ( model_path = "path/to/chatml/llama-model.gguf" , chat_format = "chatml-function-calling" )
llm . create_chat_completion (
messages = [
{
"role" : "system" ,
"content" : "A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. The assistant calls functions with appropriate input when necessary"
},
{
"role" : "user" ,
"content" : "Extract Jason is 25 years old"
}
],
tools = [{
"type" : "function" ,
"function" : {
"name" : "UserDetail" ,
"parameters" : {
"type" : "object" ,
"title" : "UserDetail" ,
"properties" : {
"name" : {
"title" : "Name" ,
"type" : "string"
},
"age" : {
"title" : "Age" ,
"type" : "integer"
}
},
"required" : [ "name" , "age" ]
}
}
}],
tool_choice = {
"type" : "function" ,
"function" : {
"name" : "UserDetail"
}
}
) Les différents fichiers convertis en gguf pour cet ensemble de modèles peuvent être trouvés ici. Le fonctionnaire est capable d'appeler intelligemment des fonctions et également d'analyser toutes les sorties de fonction fournies pour générer des réponses cohérentes. Tous les modèles v2 de fonctionnels prennent en charge les appels de fonctions parallèles . Vous pouvez fournir soit functionary-v1 , soit functionary-v2 pour chat_format lors de l'initialisation de la classe Llama.
En raison de divergences entre llama.cpp et les tokenizers de HuggingFace, il est nécessaire de fournir un tokenizer HF pour les fonctionnaires. La classe LlamaHFTokenizer peut être initialisée et transmise à la classe Llama. Cela remplacera le tokenizer llama.cpp par défaut utilisé dans la classe Llama. Les fichiers tokenizer sont déjà inclus dans les référentiels HF respectifs hébergeant les fichiers gguf.
from llama_cpp import Llama
from llama_cpp . llama_tokenizer import LlamaHFTokenizer
llm = Llama . from_pretrained (
repo_id = "meetkai/functionary-small-v2.2-GGUF" ,
filename = "functionary-small-v2.2.q4_0.gguf" ,
chat_format = "functionary-v2" ,
tokenizer = LlamaHFTokenizer . from_pretrained ( "meetkai/functionary-small-v2.2-GGUF" )
)REMARQUE : Il n'est pas nécessaire de fournir les messages système par défaut utilisés dans Functionary car ils sont ajoutés automatiquement dans le gestionnaire de discussion Functionary. Ainsi, les messages doivent contenir uniquement les messages de discussion et/ou les messages système qui fournissent un contexte supplémentaire pour le modèle (par exemple : datetime, etc.).
llama-cpp-python prend en charge tel que llava1.5 qui permet au modèle de langage de lire les informations à la fois du texte et des images.
Vous trouverez ci-dessous les modèles multimodaux pris en charge et leurs gestionnaires de discussion respectifs (API Python) et formats de discussion (API serveur).
| Modèle | LlamaChatHandler | chat_format |
|---|---|---|
| lava-v1.5-7b | Llava15ChatHandler | llava-1-5 |
| lava-v1.5-13b | Llava15ChatHandler | llava-1-5 |
| lava-v1.6-34b | Llava16ChatHandler | llava-1-6 |
| rêve lunaire2 | MoondreamChatHandler | moondream2 |
| nanollava | NanollavaChatHandler | nanollava |
| lama-3-vision-alpha | Llama3VisionAlphaChatHandler | llama-3-vision-alpha |
| minicpm-v-2.6 | MiniCPMv26ChatHandler | minicpm-v-2.6 |
Ensuite, vous devrez utiliser un gestionnaire de discussion personnalisé pour charger le modèle de clip et traiter les messages et les images de discussion.
from llama_cpp import Llama
from llama_cpp . llama_chat_format import Llava15ChatHandler
chat_handler = Llava15ChatHandler ( clip_model_path = "path/to/llava/mmproj.bin" )
llm = Llama (
model_path = "./path/to/llava/llama-model.gguf" ,
chat_handler = chat_handler ,
n_ctx = 2048 , # n_ctx should be increased to accommodate the image embedding
)
llm . create_chat_completion (
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : [
{ "type" : "text" , "text" : "What's in this image?" },
{ "type" : "image_url" , "image_url" : { "url" : "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } }
]
}
]
) Vous pouvez également extraire le modèle du Hugging Face Hub à l'aide de la méthode from_pretrained .
from llama_cpp import Llama
from llama_cpp . llama_chat_format import MoondreamChatHandler
chat_handler = MoondreamChatHandler . from_pretrained (
repo_id = "vikhyatk/moondream2" ,
filename = "*mmproj*" ,
)
llm = Llama . from_pretrained (
repo_id = "vikhyatk/moondream2" ,
filename = "*text-model*" ,
chat_handler = chat_handler ,
n_ctx = 2048 , # n_ctx should be increased to accommodate the image embedding
)
response = llm . create_chat_completion (
messages = [
{
"role" : "user" ,
"content" : [
{ "type" : "text" , "text" : "What's in this image?" },
{ "type" : "image_url" , "image_url" : { "url" : "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg" } }
]
}
]
)
print ( response [ "choices" ][ 0 ][ "text" ])Remarque : les modèles multimodaux prennent également en charge l'appel d'outils et le mode JSON.
Les images peuvent être transmises sous forme d’URI de données codées en base64. L'exemple suivant montre comment procéder.
import base64
def image_to_base64_data_uri ( file_path ):
with open ( file_path , "rb" ) as img_file :
base64_data = base64 . b64encode ( img_file . read ()). decode ( 'utf-8' )
return f"data:image/png;base64, { base64_data } "
# Replace 'file_path.png' with the actual path to your PNG file
file_path = 'file_path.png'
data_uri = image_to_base64_data_uri ( file_path )
messages = [
{ "role" : "system" , "content" : "You are an assistant who perfectly describes images." },
{
"role" : "user" ,
"content" : [
{ "type" : "image_url" , "image_url" : { "url" : data_uri }},
{ "type" : "text" , "text" : "Describe this image in detail please." }
]
}
] llama-cpp-python prend en charge le décodage spéculatif qui permet au modèle de générer des complétions basées sur un brouillon de modèle.
Le moyen le plus rapide d’utiliser le décodage spéculatif consiste à utiliser la classe LlamaPromptLookupDecoding .
Transmettez-le simplement comme brouillon de modèle à la classe Llama lors de l'initialisation.
from llama_cpp import Llama
from llama_cpp . llama_speculative import LlamaPromptLookupDecoding
llama = Llama (
model_path = "path/to/model.gguf" ,
draft_model = LlamaPromptLookupDecoding ( num_pred_tokens = 10 ) # num_pred_tokens is the number of tokens to predict 10 is the default and generally good for gpu, 2 performs better for cpu-only machines.
) Pour générer des intégrations de texte, utilisez create_embedding ou embed . Notez que vous devez transmettre embedding=True au constructeur lors de la création du modèle pour que celui-ci fonctionne correctement.
import llama_cpp
llm = llama_cpp . Llama ( model_path = "path/to/model.gguf" , embedding = True )
embeddings = llm . create_embedding ( "Hello, world!" )
# or create multiple embeddings at once
embeddings = llm . create_embedding ([ "Hello, world!" , "Goodbye, world!" ])Il existe deux notions principales d'intégrations dans un modèle de style Transformer : le niveau de jeton et le niveau de séquence . Les intégrations au niveau de la séquence sont produites en « regroupant » les intégrations au niveau du jeton, généralement en les faisant la moyenne ou en utilisant le premier jeton.
Les modèles explicitement orientés vers les intégrations renverront généralement par défaut des intégrations au niveau de la séquence, une pour chaque chaîne d'entrée. Les modèles sans intégration tels que ceux conçus pour la génération de texte renvoient généralement uniquement des intégrations au niveau du jeton, une pour chaque jeton dans chaque séquence. Ainsi, la dimensionnalité du type de retour sera supérieure d'un cran pour les intégrations au niveau du jeton.
Il est possible de contrôler le comportement du pooling dans certains cas en utilisant l'indicateur pooling_type lors de la création du modèle. Vous pouvez garantir l'intégration au niveau du jeton à partir de n'importe quel modèle en utilisant LLAMA_POOLING_TYPE_NONE . L'inverse, obtenir un modèle orienté génération pour produire des intégrations au niveau de la séquence n'est actuellement pas possible, mais vous pouvez toujours effectuer le pooling manuellement.
La fenêtre contextuelle des modèles Llama détermine le nombre maximum de jetons pouvant être traités en même temps. Par défaut, ce nombre est défini sur 512 jetons, mais peut être ajusté en fonction de vos besoins.
Par exemple, si vous souhaitez travailler avec des contextes plus larges, vous pouvez agrandir la fenêtre contextuelle en définissant le paramètre n_ctx lors de l'initialisation de l'objet Llama :
llm = Llama ( model_path = "./models/7B/llama-model.gguf" , n_ctx = 2048 ) llama-cpp-python propose un serveur Web qui vise à remplacer l'API OpenAI. Cela vous permet d'utiliser des modèles compatibles llama.cpp avec n'importe quel client compatible OpenAI (bibliothèques de langues, services, etc.).
Pour installer le package serveur et commencer :
pip install ' llama-cpp-python[server] '
python3 -m llama_cpp.server --model models/7B/llama-model.ggufSemblable à la section Accélération matérielle ci-dessus, vous pouvez également installer avec la prise en charge du GPU (cuBLAS) comme ceci :
CMAKE_ARGS= " -DGGML_CUDA=on " FORCE_CMAKE=1 pip install ' llama-cpp-python[server] '
python3 -m llama_cpp.server --model models/7B/llama-model.gguf --n_gpu_layers 35Accédez à http://localhost:8000/docs pour consulter la documentation OpenAPI.
Pour vous lier à 0.0.0.0 afin d'activer les connexions à distance, utilisez python3 -m llama_cpp.server --host 0.0.0.0 . De même, pour changer le port (la valeur par défaut est 8000), utilisez --port .
Vous souhaiterez probablement également définir le format de l'invite. Pour chatml, utilisez
python3 -m llama_cpp.server --model models/7B/llama-model.gguf --chat_format chatmlCela formatera l'invite en fonction de la manière dont le modèle l'attend. Vous pouvez trouver le format d'invite dans la fiche modèle. Pour les options possibles, consultez llama_cpp/llama_chat_format.py et recherchez les lignes commençant par « @register_chat_format ».
Si huggingface-hub est installé, vous pouvez également utiliser l'indicateur --hf_model_repo_id pour charger un modèle à partir de Hugging Face Hub.
python3 -m llama_cpp.server --hf_model_repo_id Qwen/Qwen2-0.5B-Instruct-GGUF --model ' *q8_0.gguf 'Une image Docker est disponible sur GHCR. Pour exécuter le serveur :
docker run --rm -it -p 8000:8000 -v /path/to/models:/models -e MODEL=/models/llama-model.gguf ghcr.io/abetlen/llama-cpp-python:latestDocker sur termux (nécessite root) est actuellement le seul moyen connu de l'exécuter sur les téléphones, voir le problème de support de termux
Référence API
L'API de bas niveau est une liaison directe ctypes à l'API C fournie par llama.cpp . L'intégralité de l'API de bas niveau se trouve dans llama_cpp/llama_cpp.py et reflète directement l'API C dans lama.h.
Vous trouverez ci-dessous un court exemple montrant comment utiliser l'API de bas niveau pour tokeniser une invite :
import llama_cpp
import ctypes
llama_cpp . llama_backend_init ( False ) # Must be called once at the start of each program
params = llama_cpp . llama_context_default_params ()
# use bytes for char * params
model = llama_cpp . llama_load_model_from_file ( b"./models/7b/llama-model.gguf" , params )
ctx = llama_cpp . llama_new_context_with_model ( model , params )
max_tokens = params . n_ctx
# use ctypes arrays for array params
tokens = ( llama_cpp . llama_token * int ( max_tokens ))()
n_tokens = llama_cpp . llama_tokenize ( ctx , b"Q: Name the planets in the solar system? A: " , tokens , max_tokens , llama_cpp . c_bool ( True ))
llama_cpp . llama_free ( ctx )Consultez le dossier d'exemples pour plus d'exemples d'utilisation de l'API de bas niveau.
La documentation est disponible via https://llama-cpp-python.readthedocs.io/. Si vous rencontrez des problèmes avec la documentation, veuillez ouvrir un problème ou soumettre un PR.
Ce package est en cours de développement actif et j'apprécie toute contribution.
Pour commencer, clonez le référentiel et installez le package en mode modifiable/développement :
git clone --recurse-submodules https://github.com/abetlen/llama-cpp-python.git
cd llama-cpp-python
# Upgrade pip (required for editable mode)
pip install --upgrade pip
# Install with pip
pip install -e .
# if you want to use the fastapi / openapi server
pip install -e .[server]
# to install all optional dependencies
pip install -e .[all]
# to clear the local build cache
make clean Vous pouvez également tester des validations spécifiques de llama.cpp en vérifiant la validation souhaitée dans le sous-module vendor/llama.cpp , puis en exécutant make clean et pip install -e . encore. Toute modification apportée à l'API llama.h nécessitera des modifications du fichier llama_cpp/llama_cpp.py pour correspondre à la nouvelle API (des modifications supplémentaires peuvent être nécessaires ailleurs).
