Talent Angels LFX Mentorship - Onboarding & Setup Guide

Project: Talent Angels @ Learning Tokens: AI Graph Agents for Human Skills Empowerment
Mentee: Aman Sarraf
Mentorship: LF Decentralized Trust, 2026 Cohort

1. What This Project Actually Is

One-liner: Build AI agents that query knowledge graphs of global skills/occupations taxonomies, so humans can discover learning paths between any two skills or jobs.

The problem: Skills, tasks, and occupations are scattered across incompatible taxonomies (ESCO, O*NET, SFIA, BLS, Lightcast). No unified way exists for a person to ask "What skills do I need to go from Data Analyst to ML Engineer?" and get a reasoned answer across these databases.

Your solution: A suite of 3 AI Graph Agents that build and traverse knowledge graphs from these taxonomies:

A future 4th agent (Evaluator) would rank paths by relevance and alignment with a user's profile.

Architecture pattern: GraphRAG (Graph-based Retrieval-Augmented Generation) - the agents use knowledge graphs as their retrieval layer instead of plain vector search.

This extends the existing Learning Tokens lab, which tokenizes learning achievements on-chain. Your agents provide the skill metadata layer that makes those tokens meaningful.

2. The Existing Codebase (Learning Tokens)

The repo at hyperledger-labs/learning-tokens has these components:

Your work is largely net-new. You're building the AI agent layer, not modifying the existing smart contract or dashboard code. But you need to understand the Learning Tokens domain model (institutions > instructors > courses > skills > learners) since your agents will eventually feed skill metadata into this system.

3. The 5 Taxonomies You'll Work With

Start with O*NET and ESCO - they have the richest, most accessible APIs and well-defined skill-occupation relationships that naturally form graphs.

4. Local Machine Setup (macOS)

4.1 Core Tools

# Homebrew (if not installed)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Python 3.11+
brew install python@3.11
python3 --version

# Node.js 18+ (for existing Learning Tokens codebase)
brew install node@18

# Git (likely already installed)
brew install git

# Docker Desktop (for Neo4j and the existing blockchain test network)
brew install --cask docker

4.2 Graph Database - Neo4j

This is the core of your project. Install locally to experiment:

# Option A: Docker (recommended - cleanest)
docker run -d \
  --name neo4j \
  -p 7474:7474 -p 7687:7687 \
  -e NEO4J_AUTH=neo4j/password123 \
  -e NEO4J_PLUGINS='["apoc","graph-data-science"]' \
  neo4j:5

# Option B: Homebrew
brew install neo4j
neo4j start

After starting, open http://localhost:7474 to access the Neo4j Browser. Login with neo4j/password123 (or whatever you set).

4.3 Python Environment

# Create project directory
mkdir -p ~/Developer/talent-angels && cd ~/Developer/talent-angels

# Virtual environment
python3 -m venv venv
source venv/bin/activate

# Core dependencies you'll need
pip install \
  langchain langchain-anthropic langchain-community \
  neo4j \
  anthropic \
  requests httpx \
  python-dotenv \
  pydantic \
  jupyter notebook

4.4 Claude Code (Your AI Coding Tool)

# Install Claude Code
npm install -g @anthropic-ai/claude-code

# Authenticate
claude login

# Start using it in your project
cd ~/Developer/talent-angels
claude

How to use Claude Code effectively for this project:

• Use it to scaffold boilerplate (Neo4j connection classes, API client wrappers, agent tool definitions)

• Have it write Cypher queries by describing the graph pattern you want

• Ask it to review your agent prompts and suggest improvements

• Use /init to create a CLAUDE.md file in your repo so Claude Code understands your project context

4.5 Clone the Existing Repo

cd ~/Developer
git clone https://github.com/hyperledger-labs/learning-tokens.git
cd learning-tokens
# Browse around to understand the structure

5. Key Concepts to Learn Before Starting

5.1 Knowledge Graphs & Neo4j (Weeks 1-2 of mentorship)

What to learn:

• Property graph model (nodes, relationships, properties)

• Cypher query language (Neo4j's SQL-equivalent)

• Graph traversal patterns (shortest path, variable-length paths)

• APOC library (utility procedures for Neo4j)

Hands-on exercises:

-- Create a tiny skills graph to get familiar
CREATE (py:Skill {name: "Python", category: "Programming"})
CREATE (ml:Skill {name: "Machine Learning", category: "AI"})
CREATE (stats:Skill {name: "Statistics", category: "Math"})
CREATE (da:Occupation {name: "Data Analyst"})
CREATE (mle:Occupation {name: "ML Engineer"})

CREATE (da)-[:REQUIRES]->(py)
CREATE (da)-[:REQUIRES]->(stats)
CREATE (mle)-[:REQUIRES]->(py)
CREATE (mle)-[:REQUIRES]->(ml)
CREATE (ml)-[:PREREQUISITE]->(stats)

-- Find path from Data Analyst to ML Engineer
MATCH path = shortestPath(
  (a:Occupation {name: "Data Analyst"})-[*]-(b:Occupation {name: "ML Engineer"})
)
RETURN path

Resources:

• Neo4j GraphAcademy - free courses, start with "Neo4j Fundamentals" and "Cypher Fundamentals"

• Neo4j + LLM course - directly relevant

5.2 Agentic AI Design (Weeks 3-4)

What to learn:

• Tool use / function calling with LLMs

• System prompt design (persona, instructions, guardrails)

• Agent orchestration patterns (routing, chaining, parallel)

• LangChain/LangGraph basics

Key pattern for this project:

User Query
  -> LLM interprets intent (which agent? which taxonomy?)
  -> Agent selects tools (Cypher query generator, API caller, graph traverser)
  -> Tool executes against Neo4j / taxonomy APIs
  -> LLM synthesizes results into natural language

Resources:

• Anthropic's tool use docs

• LangGraph docs - for multi-agent orchestration

• Building Effective Agents - Anthropic's guide

5.3 GraphRAG

Regular RAG retrieves text chunks from a vector database. GraphRAG retrieves structured relationships from a knowledge graph. For your project:

• Nodes = skills, tasks, occupations, competencies

• Edges = REQUIRES, ENABLES, PART_OF, PREREQUISITE, RELATED_TO

• Queries = graph traversals (not vector similarity searches)

Resources:

• Neo4j GraphRAG for Python - official library

• Microsoft's GraphRAG paper - foundational reading

6. Pre-Mentorship Preparation Plan

Do these before or during the first 2 weeks to hit the ground running:

Week -2 to -1 (Before start)

Week 1 (First week of mentorship)

7. Starter Project: Build a Minimal Locator Agent

Here's a concrete mini-project to validate your setup and build muscle memory:

# talent_angels/locator.py
"""Minimal Locator agent that finds skills/occupations in a Neo4j graph."""

import anthropic
from neo4j import GraphDatabase
import json

# Neo4j connection
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password123"))

# Define the tool for Claude
tools = [
    {
        "name": "search_graph",
        "description": "Search the skills/occupations knowledge graph using a Cypher query",
        "input_schema": {
            "type": "object",
            "properties": {
                "cypher_query": {
                    "type": "string",
                    "description": "A Neo4j Cypher query to execute against the skills graph"
                }
            },
            "required": ["cypher_query"]
        }
    }
]

def run_cypher(query: str) -> list:
    with driver.session() as session:
        result = session.run(query)
        return [record.data() for record in result]

def chat(user_message: str):
    client = anthropic.Anthropic()
    
    messages = [{"role": "user", "content": user_message}]
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="""You are a Locator agent for the Talent Angels system. 
        You help users find skills, tasks, and occupations in a knowledge graph.
        The graph has :Skill and :Occupation nodes connected by :REQUIRES relationships.
        Generate Cypher queries to answer user questions about skills and occupations.""",
        tools=tools,
        messages=messages,
    )
    
    # Handle tool use
    while response.stop_reason == "tool_use":
        tool_block = next(b for b in response.content if b.type == "tool_use")
        result = run_cypher(tool_block.input["cypher_query"])
        
        messages.append({"role": "assistant", "content": response.content})
        messages.append({
            "role": "user",
            "content": [{"type": "tool_result", "tool_use_id": tool_block.id, "content": json.dumps(result)}]
        })
        
        response = client.messages.create(
            model="claude-sonnet-4-20250514", max_tokens=1024,
            system="You are a Locator agent...",  # same system prompt
            tools=tools, messages=messages,
        )
    
    return response.content[0].text

if __name__ == "__main__":
    print(chat("What skills does a Data Scientist need?"))

This is ~60 lines and exercises: Neo4j connection, Anthropic tool use, Cypher generation, and the Locator agent pattern. Extend it to become the real thing.

8. How You'll Use Claude Code Day-to-Day

# In your project directory
cd ~/Developer/talent-angels
claude

# Example prompts:
# "Write a Python script to download O*NET occupation data and load it into Neo4j"
# "Create a Cypher query that finds all paths between two skills up to 4 hops"
# "Design the system prompt for the Connector agent"
# "Review my agent code and suggest improvements for error handling"
# "Write tests for the Locator agent's Cypher generation"

Tips for AI-assisted development on this project:

• Start each session with context: "I'm building AI graph agents for skill taxonomy querying. Here's my current code..."

• Use Claude Code to write Cypher queries - describe the pattern in English, let it generate the query

• Have it scaffold new agent classes following the pattern of your first working agent

• Use it for prompt engineering - iterate on system prompts for each agent type

9. Mentorship Timeline Mapped to Deliverables

10. Quick Reference: Key Links