Learning Plan Generator

A LangGraph-based workflow that turns a user’s goal role, current skills, and skill gaps into a tailored Georgia Tech learning plan. The pipeline combines LLM-based extraction, job scraping, embedding-based similarity matching, clustering, vector search over course data, and final synthesis into a concise course plan.

What this project does

The system is designed to answer a simple but practical question:

“Given my target role, what should I learn next to close the most important skill gaps?”

It does this by:

1. Parsing a free-form user profile into structured role, skills, and gaps.
2. Retrieving recent, relevant job postings for the target role.
3. Extracting hard skills from those job descriptions.
4. Clustering recurring skills into higher-level skill themes.
5. Prioritizing the most important gaps and skill themes.
6. Searching a Georgia Tech course vector database for the best matching courses.
7. Producing a final learning plan explaining why those courses are a good fit.

---

High-level architecture

The project is implemented as a LangGraph state machine with several nodes that run in sequence.

flowchart TD
    A[Profile extraction] --> B{Role clarified?}
    B -->|No| C[Role clarification]
    B -->|Yes| D{Skills/gaps recognized?}
    C --> A
    D -->|No| E[Input confirmation]
    E -->|Retry| A
    E -->|Confirm| F[Job retrieval]
    D -->|Yes| F
    F --> G[Skill extraction]
    G --> H[Skill clustering]
    H --> I[Department identification]
    I --> J[Gap analysis & course search]
    J --> K[Learning plan synthesis]

Loading

---

End-to-end workflow

1. Profile extraction

The first node, profile extraction, receives the user’s raw input:

• target role
• current skills
• current gaps

And outputs:

• a cleaned goal role
• a dictionary of skills with proficiency levels
• a dictionary of gaps with severity levels
• routing flags for clarification or confirmation

2. Routing and validation

The graph uses conditional routing to decide what happens next:

• If the role cannot be inferred, the workflow asks the user to clarify it.
• If the model cannot find meaningful skills or gaps, the workflow asks the user to confirm or re-enter input.
• Otherwise, it proceeds to job retrieval.

3. Job retrieval

The workflow fetches recent U.S. job postings from configured Greenhouse and Ashby job boards. The job lists are filtered for:

• recent jobs only
• jobs whose title is semantically related to the target role

The relatedness check uses embedding similarity with Sentence Transformers, comparing the user’s target role against the job title.

4. Skill extraction from job descriptions

Once relevant jobs are collected, the system sends batches of job descriptions to an LLM prompt that extracts hard skills from each job. The goal is to capture skills such as:

• programming languages
• frameworks and libraries
• ML/AI methods
• data tools
• engineering concepts
• infrastructure and platform skills

The extracted skills are collected into a flat list for later clustering.

5. Skill clustering and naming

The raw extracted skills are normalized and aggregated by frequency. Then the system:

• embeds the unique skills
• performs hierarchical agglomerative clustering to group similar skills into clusters
• keeps only clusters that appear frequently enough in the job set

This produces a set of “in-demand skill themes” such as machine learning, data engineering, systems design, or cloud infrastructure.

6. Department identification

The workflow uses the role and the extracted skill concepts to identify which Georgia Tech course department groups are relevant. This narrows the course search so that recommendations remain focused on the most relevant academic areas.

7. Gap analysis and course search

This is the core recommendation step.

The system builds a prioritized set of search terms from:

• user gaps (weighted by severity: large, medium, small)
• frequent in-demand skill cluster names

It also filters out any cluster-based term that is too semantically similar to a user skill the user already claims to have at a medium or high level.

The ranked terms are then searched against a Chroma vector database of Georgia Tech courses. Each course receives a score based on:

• similarity to the prioritized search terms
• the weight of the source term (gaps usually score higher than job description-extracted skills)
• how many terms matched the course

8. Learning plan synthesis

Finally, the top-ranked courses are passed to a synthesizing LLM, which writes a short learning plan explaining:

• why the selected courses were chosen
• how they address the user’s gaps
• which in-demand skills they support
• how they connect to the target role

---

How to run

1. Install dependencies

python -m pip install -r requirements.txt

2. Ensure Ollama is available

This project expects an Ollama-capable environment with the qwen3:8b model available.

3. Build or refresh the course vector database (if needed)

python scripts/create_vector_db.py

4. Run the workflow

python main.py

The script will prompt you for:

• your goal role
• your current skills
• your current gaps

Then it will produce a final learning plan.

---

Summary

This project is essentially a role-aware course recommendation system for Georgia Tech. It combines:

• LLM-based understanding of a user profile
• job market signal extraction from real postings
• clustering of recurring skills into themes
• semantic retrieval over a course corpus
• final synthesis into a practical learning plan

The result is an AI pipeline that moves from unstructured input to personalized academic recommendations.