3 façons d’exécuter DeepSeek et Llama en local

12 février 2025 · 4 min de lecture

Les Large Language Models (LLMs) ont transformé le paysage IA, et les petits modèles progressent vite. Il devient donc possible d’exécuter des LLMs avancés même sur des PC plus anciens et certains smartphones. Pour commencer, regardons trois méthodes pour interagir localement avec Llama 3.3 ou DeepSeek.

En bref

• Package Python: utilisez Ollama pour des chats simples ou en streaming avec des modèles comme deepseek-r1:1.5b.
• API: utilisez l’API HTTP locale d’Ollama pour une intégration flexible dans n’importe quel langage.
• LangChain: créez des applications plus avancées (analyse documentaire, recherche contextuelle) avec embeddings et bases vectorielles.

Prérequis

Avant de commencer :

• Ollama installé et en cours d’exécution

Quel modèle choisir ?

Quelle version est assez petite pour tourner localement ? Mon approche: tester. Commencez par la plus petite, puis montez progressivement pour trouver la limite de votre machine.

Pour voir les versions disponibles sur Ollama : https://ollama.com/search.

Par exemple, pour deepseek-r1, la plus petite version est 1.5b. Dans le terminal :

ollama pull deepseek-r1:1.5b

On obtient :

Le modèle fait un peu plus de 1,1 Go. Correct.
Pour un test rapide :

ollama run deepseek-r1:1.5b

Sortie :

>>> Send a message (/? for help)

Envoyons un message :

Le résultat est impressionnant.

Méthode 1 : package Python Ollama

Le package Python Ollama permet d’intégrer DeepSeek 1.5b de manière directe dans des scripts Python ou des notebooks.

import ollama

response = ollama.chat(
    model="deepseek-r1:1.5b",
    messages=[
        {
            "role": "user",
            "content": "Tell me an interesting fact about elephants",
        },
    ],
)
print(response["message"]["content"])

La réponse est nettement plus longue que 50 mots (j’ai aussi testé la version 32b avec la même question, sans énorme différence).
Continuons sur l’aspect implémentation.

Pour le streaming, utilisez AsyncClient :

import asyncio
from ollama import AsyncClient

async def chat():
    message = {
        "role": "user",
        "content": "Tell me an interesting fact about elephants"
    }
    async for part in await AsyncClient().chat(
        model="deepseek-r1:1.5b", messages=[message], stream=True
    ):
        print(part["message"]["content"], end="", flush=True)

# Run the async function
async def main():
    await chat()

# Check if there's a running event loop and use it, otherwise create a new one
try:
    loop = asyncio.get_running_loop()
except RuntimeError:
    loop = None

if loop and loop.is_running():
    asyncio.ensure_future(main())
else:
    asyncio.run(main())

Méthode 2 : API Ollama

Si vous préférez les APIs directes ou une intégration hors Python, Ollama propose une API HTTP simple.

curl http://localhost:11434/api/chat -d '{
>     "model": "deepseek-r1:1.5b",
>     "messages": [
>         {
>             "role": "user",
>             "content": "What are God Particles?"
>         }
>     ],
>     "stream": false
> }'

Cette méthode est flexible et compatible avec tout environnement capable d’émettre des requêtes HTTP.

Méthode 3 : LangChain pour des usages avancés

Pour des scénarios plus complexes (analyse documentaire, retrieval), LangChain s’intègre bien avec Ollama et Llama 3.2.
Exemple avec chargement de documents, embeddings et recherche de similarité sur un article Wikipédia sur Thomas Jefferson sauvegardé en Word.
Pensez à installer python-docx (ex. pip install python-docx).

from langchain_community.document_loaders import DirectoryLoader, UnstructuredWordDocumentLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.llms import Ollama
from langchain_community.vectorstores import Chroma

# Load documents
loader = DirectoryLoader('/path/to/documents', glob="**/*.docx", loader_cls=UnstructuredWordDocumentLoader)
documents = loader.load()

# Split documents into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
splits = text_splitter.split_documents(documents)

# Create embeddings and vector store
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(documents=splits, embedding=embeddings)

# Initialize LLama 3.2 1B
llm = Ollama(model="llama3.2:1b", base_url="http://localhost:11434")

# Perform a similarity search and generate a response
query = "What was the main accomplishment of Thomas Jefferson?"
similar_docs = vectorstore.similarity_search(query)
context = "\n".join([doc.page_content for doc in similar_docs])
response = llm(f"Context: {context}\nQuestion: {query}\nAnswer:")
print(response)

Réponse du modèle :

La réponse n’est pas parfaite, mais cette méthode montre comment bâtir des apps capables d’exploiter de gros volumes de texte avec Llama, DeepSeek et d’autres modèles.

Conclusion

Exécuter Llama 3.2, DeepSeek et d’autres modèles Ollama en local ouvre beaucoup de possibilités pour des applications IA.
Chat simple, intégration API ou analyse documentaire avancée: ces trois méthodes couvrent un large éventail de besoins.
Utilisez ces outils de manière responsable et éthique.