Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Ollama & Local LLMs: Fine-Tune, Deploy, Build Python AI Apps
Highest Rated
Rating: 4.6 out of 5(9,471 ratings)
21,146 students

Ollama & Local LLMs: Fine-Tune, Deploy, Build Python AI Apps

Build Private AI on Your PC: Unsloth QLoRA, Ship Models to Ollama, Streamlit RAG Apps, a Full Coding-Assistant Capstone
Last updated 6/2026
English

What you'll learn

  • Use Ollama from Python: chat, streaming, generation.
  • Build Streamlit UIs on top of local models.
  • Add vision: images with multimodal models (e.g. LLaVA-style flows).
  • Handle video: frames, Whisper transcription, Q&A over audio.
  • Do PDF Q&A and document-grounded prompts.
  • Use LangChain: Ollama integration, templates, LLMChain, multi-input prompts.
  • Chunk long text and summarize with map-style workflows.
  • Use spaCy embeddings: similarity, semantic search, RAG over long text.
  • Build note/diary style personal knowledge apps.
  • Run CrewAI agents with Ollama (sequential and domain examples).
  • Run Hugging Face transformers locally; manage cache and disk use.
  • Try TTS and text-to-video scripts where GPU allows.
  • Run Unsloth inference (e.g. SmolLM2), inspect tokenizer and model behavior.
  • Fine-tune with Unsloth + QLoRA; watch validation for forgetting.
  • Test base vs fine-tuned models; merge LoRA adapters.
  • Export to Ollama (Modelfile, quantization tradeoffs).
  • Capstone: local LLM coding assistant (editor, chat, diffs, run code, shell, optional web research, planning, persistence).

Course content

7 sections60 lectures16h 38m total length
  • Introduction12:05
  • Do not Hesitate to Ask Questions1:59

Requirements

  • Basic Knowledge of Python

Description

If you are tired of black-box cloud APIs and want AI that runs on your hardware, keeps your data local, and still ships like a real product, this course gives you a complete path from first Python call to a deployable model and a capstone app you can show in a portfolio.

You start with Olloma + Python (chat, streaming, generation patterns you reuse everywhere), then move into Streamlit apps, RAG-style assistants, multi-agent workflows, Unsloth + QLoRA fine-tuning, export into Ollama, and finish with a full local coding assistant (browser, editor, diffs, run code, shell, optional web research and vision hooks). Theory never floats alone: every idea maps to working code and a clear next step.

What makes this course practical

You build, not only watch. Expect real tools: chat UIs, PDF Q&A, embedding search, personal note and diary apps, CrewAI agent teams, Whisper + Ollama video Q&A, and a large Streamlit coding IDE powered by Ollama. You also fine-tune a small instruct model, compare base vs fine-tuned answers, merge adapters, and ship the result through Ollama, including straight talk on quantization and quality so your exports behave the way you expect.

In this course, you will

  • Wire up Ollama from Python using chat, streaming, and generation patterns that repeat across the whole curriculum.

  • Ship Streamlit front ends on top of local models, including vision demos and media flows (frames, Whisper transcription, questions over audio).

  • Build retrieval-style assistants: PDF context, LangChain templates and chains, chunking for long text, and spaCy embedding search from similarity through full chunk retrieval.

  • Orchestrate multi-step AI with LangChain and CrewAI (Ollama-backed agents, sequential workflows, domain-style examples).

  • Run Hugging Face models locally and stretch into extra modalities when your hardware allows (text-to-speech, text-to-video runners).

  • Train a personalized small LLM with Unsloth + QLoRA, watch validation for catastrophic forgetting, test against the base model, merge adapters, and package for Ollama with a Modelfile and export notes you can follow on a real machine.

  • Finish a capstone: a local LLM-assisted coding environment (project browser, editor, streaming chat, apply changes with diff review, run code and shell, optional web research, planning, persistence, and more).

Why local LLMs matter

You own your stack: privacy, predictable cost, and the freedom to specialize a model on your data and ship prototypes without betting everything on one cloud provider.

Why learn from this course

You get numbered, file-based progression, copy-paste-friendly projects, and troubleshooting for real setups (CUDA PyTorch, Windows compiler and Triton notes, protobuf conflicts, pip and Hugging Face caches). The goal is fewer weekends lost to environment issues and more time shipping.

Before you enroll

Comfortable Python basics (install packages, run scripts, read errors). A recent NVIDIA GPU is strongly recommended for fine-tuning, Unsloth work, and several advanced demos. Some lessons need ffmpeg or large downloads; plan disk space and time for first-time model pulls.

How to get the most from the course

Watch the promo, sample the free preview. When you enroll, your outcome is simple: private AI on your PC that you run, train, export, and productize yourself.

Who this course is for:

  • Python developers who want to add local LLMs to their projects.
  • Beginner-to-intermediate coders comfortable installing packages and running scripts.
  • Builders who want Streamlit apps powered by Ollama, not only CLI chat.
  • Privacy-minded learners who prefer on-device AI and local data.
  • Hobbyists and pros exploring RAG, LangChain, embeddings, and agents without a cloud-only stack.
  • Creators who want multimedia flows: images, video, Whisper audio.
  • Practitioners ready to fine-tune a small model (Unsloth, QLoRA) and ship it with Ollama.
  • Portfolio-focused students who want a capstone (local coding assistant style app).
  • Windows/Linux/macOS users willing to troubleshoot GPU, Ollama, and Python envs when needed.