DEV Community

Brian Davies
Brian Davies

Posted on

Build a Mini “Course Recommender” with Python + Embeddings in Under an Hour

#ai

Every modern learning platform — from Coursiv to Coursera — relies on recommender systems.

They decide which course, article, or tutorial you see next. And under the hood, it’s not magic — it’s embeddings.

In this tutorial, you’ll build a mini course recommender using Python and embeddings. No PhD, GPU, or months of data prep required — just clear logic and a few simple libraries.

By the end, you’ll understand the basic mechanics that power every AI-driven education platform.

What Are Embeddings (and Why They Matter)

Embeddings are numerical representations of text, meaning that each word, sentence, or paragraph is converted into a vector — a list of numbers that captures meaning and context.

In practice, this means:

  • “machine learning” and “deep learning” will have similar embeddings, since they’re related.
  • “machine learning” and “banana bread” will be far apart in vector space.

That’s how recommender systems understand semantic similarity — the ability to say, “If you liked this course, you might like that one.”

Step 1: Setting Up Your Environment

Let’s start with a lightweight setup.

You’ll need:

  • Python 3.10+
  • Libraries: openai, numpy, and scikit-learn

Install them with:

pip install openai numpy scikit-learn
Enter fullscreen mode Exit fullscreen mode

Make sure you have your OpenAI API key ready — you’ll need it to generate embeddings.

Step 2: Creating a Sample Course Dataset

We’ll simulate a small course catalog.

courses = [
    "Introduction to Machine Learning",
    "Advanced Deep Learning Techniques",
    "Getting Started with Python",
    "Frontend Development with React",
    "Mastering Data Structures in C++",
    "Ethical AI and Responsible Innovation"
]
Enter fullscreen mode Exit fullscreen mode

Step 3: Generate Embeddings for Each Course

Use OpenAI’s embeddings endpoint to convert each course into a vector.

from openai import OpenAI
import numpy as np

client = OpenAI(api_key="YOUR_API_KEY")

def get_embedding(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return np.array(response.data[0].embedding)

course_embeddings = [get_embedding(c) for c in courses]
Enter fullscreen mode Exit fullscreen mode

Now every course title is represented by a high-dimensional vector that captures meaning and similarity.

Step 4: Recommend Similar Courses

To recommend similar courses, compute cosine similarity between embeddings.

from sklearn.metrics.pairwise import cosine_similarity

def recommend(query, top_n=3):
    query_vector = get_embedding(query)
    similarities = cosine_similarity([query_vector], course_embeddings)
    sorted_indices = np.argsort(similarities[0])[::-1]
    for i in range(top_n):
        print(courses[sorted_indices[i]])
Enter fullscreen mode Exit fullscreen mode

Try it out:

recommend("AI and machine learning fundamentals")
Enter fullscreen mode Exit fullscreen mode

The system should return courses like:

  1. “Introduction to Machine Learning”
  2. “Advanced Deep Learning Techniques”
  3. “Ethical AI and Responsible Innovation”

You’ve just built a semantic recommender system using less than 40 lines of code.

Step 5: Scaling and Refining

To make this production-ready, you can:

  • Replace course titles with course descriptions for richer context.
  • Use vector databases like Pinecone or FAISS for large datasets.
  • Fine-tune relevance by weighting metadata like user ratings or skill level.

The underlying concept stays the same: find what’s closest in meaning — not keywords.

Why Coursiv Uses Embeddings to Power Personalized Learning

At Coursiv, embeddings form the backbone of our adaptive AI system.

Instead of generic recommendations, the platform uses embedding-based matching to understand what learners truly need next.

That means if you complete a microcourse on “Prompt Engineering for Developers,” Coursiv doesn’t just show another AI topic — it suggests what’s semantically aligned with your skill progression and career path.

This creates learning experiences that feel natural, personalized, and always relevant — powered by the same architecture you just built.

Conclusion: Learn It, Build It, Apply It

In under an hour, you’ve created a working course recommender — the foundation of every modern AI education platform.

The real takeaway isn’t just the code, but the concept: how machines use meaning, not labels, to connect knowledge.

To see how Coursiv scales this principle into full adaptive learning ecosystems, explore the platform at Coursiv.com — where AI turns learning into an intelligent feedback loop.

Top comments (0)