Ollama¶

import ollama

# Simple generation
response = ollama.generate(
    model='llama3.2',
    prompt='What is machine learning?'
)
print(response['response'])

import ollama

# Multi-turn chat
messages = [
    {'role': 'system', 'content': 'You are a helpful coding assistant.'},
    {'role': 'user', 'content': 'Write a Python function to calculate factorial'}
]

response = ollama.chat(
    model='llama3.2',
    messages=messages
)

print(response['message']['content'])

import ollama

# Stream responses for better UX
stream = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Explain the water cycle'}],
    stream=True
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

import ollama

# Generate embeddings for semantic search or RAG
embedding = ollama.embeddings(
    model='nomic-embed-text',  # or any embedding model
    prompt='The quick brown fox jumps over the lazy dog'
)

print(f"Embedding dimension: {len(embedding['embedding'])}")

from langchain_ollama import OllamaLLM

# Initialize the model
llm = OllamaLLM(model="llama3.2")

# Simple invocation
response = llm.invoke("What are the benefits of exercise?")
print(response)

from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage, SystemMessage

chat = ChatOllama(model="llama3.2", temperature=0.7)

messages = [
    SystemMessage(content="You are a research assistant specializing in biology."),
    HumanMessage(content="Explain CRISPR gene editing.")
]

response = chat.invoke(messages)
print(response.content)

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# Initialize components
llm = OllamaLLM(model="llama3.2")
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Sample documents (in practice, load from files)
documents = [
    "Machine learning is a subset of artificial intelligence...",
    "Neural networks are inspired by biological neurons...",
    "Deep learning uses multiple layers of neural networks..."
]

# Split documents
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
splits = text_splitter.create_documents(documents)

# Create vector store
vectorstore = Chroma.from_documents(splits, embeddings)
retriever = vectorstore.as_retriever()

# Create RAG chain
template = """Answer based on the context:
Context: {context}
Question: {question}
Answer:"""

prompt = ChatPromptTemplate.from_template(template)

rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
)

# Query
response = rag_chain.invoke("What is deep learning?")
print(response)

import requests
import json

def query_ollama(prompt, model="llama3.2", stream=False):
    """Simple function to query Ollama API."""
    response = requests.post(
        'http://localhost:11434/api/generate',
        json={
            'model': model,
            'prompt': prompt,
            'stream': stream
        }
    )

    if stream:
        # Handle streaming response
        for line in response.iter_lines():
            if line:
                chunk = json.loads(line)
                yield chunk.get('response', '')
    else:
        return response.json()['response']

# Usage
result = query_ollama("What is the capital of France?")
print(result)

# Streaming usage
for chunk in query_ollama("Tell me a story", stream=True):
    print(chunk, end='', flush=True)

# Cell 1: Install and import
!pip install ollama

import ollama

# Cell 2: List available models
models = ollama.list()
for model in models['models']:
    print(f"{model['name']}: {model['size'] / 1e9:.1f} GB")

# Cell 3: Interactive chat
response = ollama.generate(
    model='llama3.2',
    prompt='Explain the difference between correlation and causation'
)
print(response['response'])

import ollama

class ResearchAssistant:
    """A simple research assistant using Ollama."""

    def __init__(self, model='llama3.2'):
        self.model = model
        self.conversation = []

    def set_context(self, context):
        """Set the research context/system prompt."""
        self.conversation = [{
            'role': 'system',
            'content': context
        }]

    def ask(self, question):
        """Ask a question and get a response."""
        self.conversation.append({
            'role': 'user',
            'content': question
        })

        response = ollama.chat(
            model=self.model,
            messages=self.conversation
        )

        assistant_message = response['message']['content']
        self.conversation.append({
            'role': 'assistant',
            'content': assistant_message
        })

        return assistant_message

    def summarize_paper(self, abstract):
        """Summarize a research paper abstract."""
        prompt = f"""Please analyze this research abstract and provide:
1. Main research question
2. Methodology used
3. Key findings
4. Potential implications

Abstract:
{abstract}"""

        return self.ask(prompt)

# Usage in notebook
assistant = ResearchAssistant(model='llama3.2')
assistant.set_context("You are an expert in computational biology.")

response = assistant.ask("What are the latest advances in protein folding prediction?")
print(response)

# Using OpenAI library with Ollama
from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='ollama'  # Ollama doesn't require a key, but the library needs something
)

response = client.chat.completions.create(
    model='llama3.2',
    messages=[
        {'role': 'user', 'content': 'Hello!'}
    ]
)

print(response.choices[0].message.content)

import ollama

def analyze_abstract(abstract):
    """Analyze a research paper abstract."""
    prompt = f"""Analyze this research abstract and provide:
1. Research question or hypothesis
2. Methodology
3. Key findings
4. Limitations mentioned
5. Potential follow-up questions

Abstract:
{abstract}
"""

    response = ollama.generate(model='qwen2.5:7b', prompt=prompt)
    return response['response']

# Example usage
abstract = """
We present a novel approach to protein structure prediction using
graph neural networks. Our method achieves state-of-the-art results
on the CASP14 benchmark, outperforming existing methods by 15% in
GDT-TS score. We demonstrate that incorporating evolutionary
information through multiple sequence alignments significantly
improves prediction accuracy.
"""

analysis = analyze_abstract(abstract)
print(analysis)

import ollama

def improve_grant_section(text, section_type):
    """Suggest improvements for grant application sections."""
    prompt = f"""You are an experienced grant reviewer. Review this {section_type}
section and provide specific suggestions to strengthen it:

{text}

Please provide:
1. Strengths of the current text
2. Areas that need improvement
3. Specific rewrite suggestions
4. Questions a reviewer might ask"""

    response = ollama.generate(model='qwen2.5:7b', prompt=prompt)
    return response['response']

import ollama

def create_quiz_questions(topic, difficulty, num_questions):
    """Generate quiz questions on a topic."""
    prompt = f"""Create {num_questions} {difficulty}-level multiple choice questions
about {topic}. For each question:
1. Provide the question
2. Give 4 options (A, B, C, D)
3. Indicate the correct answer
4. Explain why the correct answer is right

Format clearly with separators between questions."""

    response = ollama.generate(model='llama3.2', prompt=prompt)
    return response['response']

# Generate quiz
quiz = create_quiz_questions(
    topic="the scientific method",
    difficulty="intermediate",
    num_questions=5
)
print(quiz)

import ollama

def suggest_analysis(data_description):
    """Suggest statistical analyses for a dataset."""
    prompt = f"""Based on this data description, suggest appropriate statistical
analyses and explain the rationale:

{data_description}

Please provide:
1. Recommended statistical tests/methods
2. Assumptions to check
3. Python/R code snippets for implementation
4. How to interpret potential results"""

    response = ollama.generate(model='qwen2.5:7b', prompt=prompt)
    return response['response']