# Quickstart Source: https://docs.learningcommons.org/agent-skills/getting-started/quickstart Install Learning Commons Agent Skills in Claude Code, Cursor, or Codex, connect the Knowledge Graph MCP server, and generate a K-12 lesson. ## What you'll do * [Install Agent Skills](#install-skills) to your agent runtime * [Connect Knowledge Graph](#connect-knowledge-graph) for the most accurate outputs (Recommended) * Generate a standards-aligned K-12 lesson * [Evaluate your output](/agent-skills/using-agent-skills/evaluating-outputs) to benchmark it against published rubrics ## What you'll need * An agent runtime that supports the [open Agent Skills format](https://agentskills.io/) ↗ * Claude Code * Cursor * Codex * A [Learning Commons Platform](https://platform.learningcommons.org/) ↗ API key For Knowledge Graph integration ## Steps Installation behavior may vary slightly by runtime. Check your agent's documentation for how it discovers and loads skills from installed packages. **For Claude Code**: if your project doesn't have a `.claude/` directory yet, run the following command first before proceeding with installation: ```bash theme={null} mkdir -p .claude ``` Install [`agent-skills`](https://github.com/learning-commons-org/agent-skills) ↗ into your agent runtime of choice: ```shell theme={null} npx skills add learning-commons-org/agent-skills ``` | Path | Description | | :--------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------- | | [skills/k12-lesson-planning/](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-plan-creation) ↗ | Standards-aligned lesson plan creation skill | | [skills/k12-lesson-differentiation/](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-differentiation) ↗ | Tiered lesson differentiation skill | | [skills/example-prompts.md](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md) ↗ | Example prompts by subject and workflow | Each skill includes: * `SKILL.md` — Metadata and step-by-step instructions * `references/` — Subject-specific pedagogy and output mappings * `scripts/` — Render helpers for `.docx` Word documents Knowledge Graph datasets carry varying licenses. Some datasets aren’t readily accessible by default due to license requirements. Add the [Knowledge Graph MCP server](/knowledge-graph/using-knowledge-graph/mcp-server) to your agent runtime (replace `$LC_API_KEY` with your Learning Commons Platform API key): ```shell Example for Claude Code theme={null} claude mcp add --transport http learning-commons-kg \ https://kg.mcp.learningcommons.org/mcp \ --header "Authorization: Bearer $LC_API_KEY" ``` Access to [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction) data lets the agent: * Resolve [standards](/knowledge-graph/schema-reference/standards) * Understand granular [learning components](/knowledge-graph/schema-reference/learning-components) * Trace [learning progressions](/knowledge-graph/schema-reference/learning-progressions) * Find aligned [curriculum](/knowledge-graph/schema-reference/curriculum) lessons and common misconceptions When Knowledge Graph is unavailable, the skills still run and fall back to the model's general knowledge. However, outputs grounded in Knowledge Graph are more accurate and better aligned to specific state standards. Start a new agent session and confirm that Knowledge Graph tools (e.g., `find_standard_statement`) are available. If the connector is not available, Agent Skills still produce usable output without Knowledge Graph data. They will not invent Knowledge Graph citations or attribute content to curriculum materials they have not retrieved. When Knowledge Graph is connected, skills must call MCP tools before drafting. Not calling when connected is treated as a critical failure in the skill instructions. Make a typical teaching request. Some [example prompts](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md) ↗ include: * *"I need a lesson for tomorrow on rounding to the nearest hundred for my 3rd graders."* * *"Differentiate this 6th grade food webs lesson for students below / at / and above proficiency level (find the lesson here: [https://www.calacademy.org/educators/lesson-plans/how-stable-is-your-food-web](https://www.calacademy.org/educators/lesson-plans/how-stable-is-your-food-web))"* Your agent should load the matching Agent Skill automatically. ## Related topics Learn how skills, reference files, and rubrics fit together. Explore K-12 lesson plan creation and differentiation skills. Score generated materials against published rubrics. # License Source: https://docs.learningcommons.org/agent-skills/resources/license Apache 2.0 license details for Agent Skills, with citation guidance and attribution requirements for the K-12 skill evaluation rubrics. Agent Skills code is licensed under [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) ↗. See the [LICENSE](https://github.com/learning-commons-org/agent-skills/blob/main/LICENSE) ↗ file in the agent-skills repository for the full license text. **How to cite Agent Skills:** Learning Commons (2026). Agent Skills. GitHub. [https://github.com/learning-commons-org/agent-skills](https://github.com/learning-commons-org/agent-skills) ↗. Licensed under Apache License 2.0. ## Attribution Individual evaluation rubrics may include additional attribution requirements. See the `NOTICE` files in each evaluator directory: * [K-12 Check for Understanding attribution](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-check-for-understanding/NOTICE) ↗ * [K-12 Lesson Differentiation attribution](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-lesson-differentiation/NOTICE) ↗ * [K-12 Lesson Plan Creation attribution](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-lesson-plan-creation/NOTICE) ↗ * [K-12 Lesson Prep attribution](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-lesson-prep/NOTICE) ↗ # Release notes Source: https://docs.learningcommons.org/agent-skills/resources/release-notes Agent Skills release notes covering new skills and updates, starting with the launch of the K-12 Lesson Planning and K-12 Lesson Differentiation skills. ## Added Agent Skills * [K-12 Lesson Prep](/agent-skills/skills/k12-lesson-prep) * [K-12 Check for Understanding](/agent-skills/skills/k12-check-for-understanding) We strongly recommend pairing Agent Skills with [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction) to generate standards-grounded content. Both [K-12 Lesson Prep](/agent-skills/skills/k12-lesson-prep) and [K-12 Check for Understanding](/agent-skills/skills/k12-check-for-understanding) were co-developed with [Anthropic](https://www.anthropic.com/) ↗. [K-12 Check for Understanding](/agent-skills/skills/k12-check-for-understanding) was also developed in collaboration with [Student Achievement Partners](https://learnwithsap.org/research-grounded-products/) ↗. ## Introducing Agent Skills [Agent Skills](/agent-skills/understanding-agent-skills/introduction) are ready-to-use skills that help AI assistants produce high-quality, standards-aligned K-12 teaching materials: * [K-12 Lesson Plan Creation](/agent-skills/skills/k12-lesson-plan-creation) * [K-12 Lesson Differentiation](/agent-skills/skills/k12-lesson-differentiation) We strongly recommend pairing Agent Skills with [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction) to generate standards-grounded content. Check out [GitHub](https://github.com/learning-commons-org/agent-skills) ↗ to learn more. Both [K-12 Lesson Plan Creation](/agent-skills/skills/k12-lesson-plan-creation) and [K-12 Lesson Differentiation](/agent-skills/skills/k12-lesson-differentiation) were co-developed with [Anthropic](https://www.anthropic.com/) ↗. ## Related topics Report issues or ask questions about a recent release. # Support Source: https://docs.learningcommons.org/agent-skills/resources/support Get help with Agent Skills by opening a GitHub issue or emailing Learning Commons support with questions, bug reports, and feedback. We want to hear from you. For questions or feedback, please [open an issue](https://github.com/learning-commons-org/agent-skills/issues) ↗ or reach out to us at [support@learningcommons.org](mailto:support@learningcommons.org) ↗. # Terms of use Source: https://docs.learningcommons.org/agent-skills/resources/terms-of-use Terms of use and disclaimer for Agent Skills, covering as-is availability, your responsibility to evaluate fit, and liability limits. These terms are part of [our Terms of Use ↗](https://learningcommons.org/terms-of-use/) and govern your use of our tools, datasets, documentation, and other public resources. Capitalized terms not defined here have the same meanings set out in the Terms of Use. By using any resources in this repository — including datasets, documentation, our tools Knowledge Graph, Evaluators, Agent Skills, or other downloadable assets — you agree to the following: ### 1. Intended Use * These resources are provided for exploratory, research, and other uses permitted under their respective licenses. * They are not intended for high-stakes educational decisions such as formal student evaluation, instructional placement, or grading. ### 2. Licensing & Compliance * Each resource is released under its specified license. * You must review and comply with all terms and conditions in that license, including any attribution or usage limitations described in the accompanying documentation. * Some resources (e.g., individual Evaluators, Agent Skills, datasets, or Knowledge Graph components) may have additional license or usage terms. Review the repository’s README, LICENSE, and related documentation before use. ### 3. Updates & Versioning * Resources may be updated over time to improve accuracy, add features, or correct issues. * Users should check the release information or tags to ensure they are using the latest available version. ### 4. Responsible Use * Use of these resources must comply with all applicable laws and align with our [Community Guidelines ↗](https://learningcommons.org/community-guidelines/). * You must not: * Use the data to promote discrimination, misinformation, or harm * Circumvent safeguards or ignore usage restrictions ### 5. Limitations & Accuracy * Claims of accuracy, safety, fairness, or pedagogical effectiveness should not be made solely on the basis of outputs from these tools. * Human judgment is expected when interpreting results. * Performance may vary depending on factors such as input type, grade level, data format, or technical implementation. See the documentation for any known limitations. ## Disclaimer The resources provided in the [agent-skills repository](https://github.com/learning-commons-org/agent-skills) ↗ are made available "as-is", without warranties or guarantees of any kind. They may contain inaccuracies, limitations, or other constraints depending on the context of use. By accessing or using these resources, you acknowledge that: * You are responsible for evaluating their suitability for your specific use case. * Learning Commons makes no representations about the accuracy, completeness, or fitness of these resources for any particular purpose. * Any use of the materials is at your own risk, and Learning Commons is not liable for any direct or indirect consequences that may result. Please refer to each resource's README, license, and associated docs for any additional limitations, attribution requirements, or guidance specific to that resource. # Introduction Source: https://docs.learningcommons.org/agent-skills/skills/introduction Browse the Agent Skills catalog of K-12 lesson planning and differentiation skills, plus the CSV evaluation rubrics that score each output. ## The problem AI agents can produce plausible-looking lesson materials quickly, but quality varies widely. Standards alignment, grade-level rigor, curriculum coherence, and classroom usability are hard to guarantee from a single prompt. ## What we're building ### Agent Skills Our Agent Skills package the instructions, references, and guardrails an agent needs to reliably complete specific K-12 teaching workflows. Each skill is cross-platform, model-agnostic, and produces stronger results when paired with Learning Commons [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction). | Skill | Description | Development partner | | :----------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------- | | [**K-12 Check for Understanding**](/agent-skills/skills/k12-check-for-understanding) | Generates a short, targeted math Check for Understanding (typically 1–3 items) that surfaces what a student currently understands about a specific standard. | [Anthropic](https://www.anthropic.com/) ↗ and [Student Achievement Partners](https://learnwithsap.org/research-grounded-products/) ↗ | | [**K-12 Lesson Differentiation**](/agent-skills/skills/k12-lesson-differentiation) | Adapts an existing lesson into tiered versions (below / at / above proficiency level) and for specific student needs, keeping core content consistent across tiers. | [Anthropic](https://www.anthropic.com/) ↗ | | [**K-12 Lesson Plan Creation**](/agent-skills/skills/k12-lesson-plan-creation) | Builds classroom-ready, standards-aligned lesson plans, optionally aligned to a teacher's curriculum. | [Anthropic](https://www.anthropic.com/) ↗ | | [**K-12 Lesson Prep**](/agent-skills/skills/k12-lesson-prep) | Helps a teacher internalize an existing lesson through conversation — anticipate where students will get stuck and get ready to respond in the moment. | [Anthropic](https://www.anthropic.com/) ↗ | See [example prompts](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md) ↗ for prompts that exercise each workflow. ### Rubrics This is part of a larger evaluator harness that Learning Commons plans to publish in full at a later date. Manual use instructions are included for now. Each Agent Skill comes with a corresponding rubric that assesses whether your AI-generated K-12 content is explainable and tied to authoritative sources like academic standards, learning science research, and high-quality instructional materials. | Skill | Rubrics | | :------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [**K-12 Check for Understanding**](/agent-skills/skills/k12-check-for-understanding#scoring) | [`math.csv`](https://github.com/learning-commons-org/agent-skills/tree/main/evals/k12-check-for-understanding/rubrics/math.csv) | | [**K-12 Lesson Differentiation**](/agent-skills/skills/k12-lesson-differentiation#scoring) | | | [**K-12 Lesson Plan Creation**](/agent-skills/skills/k12-lesson-plan-creation#scoring) | | | [**K-12 Lesson Prep**](/agent-skills/skills/k12-lesson-prep#scoring) | [`internalization.csv`](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-lesson-prep/rubrics/internalization.csv) | Each rubric is represented as a CSV file with the following fields: | Field | Description | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `id` | Unique criterion identifier (e.g., `P1`, `R3`) | | `bucket` | Top-level category: `P` (Pedagogy), `R` (Rigor), `O` (Output/Formatting), or `M` (Model Scaffolding) | | `conditional` | If non-empty, the criterion applies only when this condition is met (e.g., `K-5`, `ELA-Gr8+`) `conditional` criteria are applied only when the specified condition is met; otherwise, they are skipped (not failed). | | `criterion` | Short name for the criterion | | `notes` | Rationale or design notes | | `what_pass_requires` | Specific and scoreable condition that constitutes a pass | Track per-criterion pass rates across a prompt suite rather than relying on aggregate scores alone. Since criteria score independently, a failing "Rigor" criterion simply tells you something specific about cognitive demand – it does NOT mean that the output is "bad". ## Scope and limitations Remember that LLM outputs can vary across runs, especially on borderline cases. We recommend keeping a human in the loop and treating outputs as directional signals vs. definitive classroom decisions. | Limitation | Details | | :----------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Validated workflows** | Initial skills focus on K-12 lesson plan creation, differentiation, and lesson prep across math, ELA, science, and social studies, plus math Check for Understanding. | | **Knowledge Graph dependency** | Skills work without Knowledge Graph but produce the strongest outputs when connected to standards and curriculum data. | | **Curriculum coverage** | Curriculum-specific branches cover supported materials such as Illustrative Mathematics and OpenSciEd; other curricula fall back to general best practice. | Agent Skills outputs should not be used for high-stakes applications like grading, assessment, or placement decisions without human review. ## Related topics See shared and subject-specific rubrics for lesson plan outputs. See rubrics for tiered differentiation and clarifying questions. See rubrics for lesson internalization conversations and prep notes. See the five-bucket rubric for math formative Checks for Understanding. Learn how skills, rubrics, and the P/R/O/M framework work together. Install skills, connect Knowledge Graph, and try example prompts. # K-12 Check for Understanding Source: https://docs.learningcommons.org/agent-skills/skills/k12-check-for-understanding Reference for the K-12 Check for Understanding skill, which generates 1-3 formative assessment items with answer keys and interpretation guides. [Skill last updated August 28, 2026](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-check-for-understanding) The K-12 Check for Understanding Agent Skill was co-developed with [Anthropic](https://www.anthropic.com/) ↗. This skill was refined through evaluation and feedback from [Student Achievement Partners (SAP)](https://learnwithsap.org/research-grounded-products/) ↗. SAP's involvement does not imply endorsement or guarantee of how the skill is used, modified, or built on downstream. ## Overview The [K-12 Check for Understanding](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-check-for-understanding) ↗ skill generates a Check for Understanding (CFU). A CFU is a small, targeted set of 1-3 items that surfaces what a student currently understands about a concept, skill, or standard, and what a teacher should do next. The skill produces the following `.html` file artifacts in Turn 1: * **Student version** — Formative assessment itself, with CFU items only * **Teacher version** — Same items plus an answer key and an interpretation guide for each item The skill takes into account: * What the target standard or skill asks the student to know or do * Aspects of rigor the standard calls for (conceptual, procedural, application) * Common misconceptions and barriers * Grounding items in a CCSS [standard](/knowledge-graph/schema-reference/standards), its [learning components](/knowledge-graph/schema-reference/learning-components), and its position in the [learning progression](/knowledge-graph/schema-reference/learning-progressions) when connected to the [Knowledge Graph](/knowledge-graph/) This skill works with or without Knowledge Graph, but we strongly recommend connecting to it. See [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) for more information. ## At a glance | | | | :------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Workflow** | Generate a short, targeted formative Check for Understanding for a math standard or topic | | **Subject** | Math | | **Supported grades** | K–12 | | **Item count** | 1–3 items per CFU | | **Rubrics** | [`math.csv`](https://github.com/learning-commons-org/agent-skills/blob/main/evals/k12-check-for-understanding/rubrics/math.csv) ↗ — 5-bucket [P/R/O/M framework](/agent-skills/understanding-agent-skills/core-concepts#the-p-r-o-m-framework) (pedagogy, rigor, output, model scaffolding, and Knowledge Graph use) | ## Getting started Follow the [Quickstart](/agent-skills/getting-started/quickstart) to start using this skill: | Access method | | | :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- | | **Knowledge Graph MCP** | [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) | | **Example prompts** | [example-prompts.md](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md#check-for-understanding) ↗ | | **Skill instructions** | [`SKILL.md`](https://github.com/learning-commons-org/agent-skills/blob/main/skills/k12-check-for-understanding/SKILL.md) ↗ | ## Triggers Your LLM will programmatically load this skill when explicitly or implicitly prompted to create a short, targeted formative check for a math standard or topic (NOT a full lesson, unit test, or rubric): * **Explicitly**: "check for understanding," "CFU," "formative assessment," "quick check," "exit ticket" * **Implicitly**: "I want to see if my students get fractions before we move on," "give me something quick to gauge understanding of 5.NF.A.1," "what should I ask to see who's ready for the next lesson" ## Output | Artifact | Description | | :------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------- | | **Student version** | Formative assessment itself — the CFU item(s) only, formatted for a student to complete. No answer key or teacher guidance. | | **Teacher version** | Same item(s) plus the correct answer(s) and an interpretation guide: what each response reveals, and a specific, actionable suggested next step | | **Rendered files** | Self-contained `.html` files for both versions, viewable with no internet connection | ## Scoring The K-12 Check for Understanding skill's outputs are scored against a 5-bucket rubric called the [P/R/O/M framework](/agent-skills/understanding-agent-skills/core-concepts#the-p-r-o-m-framework), developed with Student Achievement Partners, that separates pedagogical fidelity from item mechanics from whether Knowledge Graph data was actually used. 1. Generate a CFU (both student and teacher versions) using this skill. 2. Apply the P, R, and O bucket criteria to every output; apply M and Q where the Knowledge Graph was used. 3. Run LLM-as-judge or human review against each criterion. See [Evaluating outputs](/agent-skills/using-agent-skills/evaluating-outputs). ## Skill release history | Date | Changed | | --------------- | --------------------------------------------------------------------------- | | August 28, 2026 | First release, developed in collaboration with Student Achievement Partners | # K-12 Lesson Differentiation Source: https://docs.learningcommons.org/agent-skills/skills/k12-lesson-differentiation Reference for the K-12 Lesson Differentiation skill, which tiers an existing lesson for below, at, and above grade level, with rubrics. [Skill last updated July 14, 2026](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-differentiation) The K-12 Lesson Differentiation Agent Skill was co-developed with [Anthropic](https://www.anthropic.com/) ↗. ## Overview The [K-12 Lesson Differentiation](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-differentiation) ↗ skill uses research-based differentiation principles (Tomlinson framework + subject-specific access design) to adapt an existing lesson for students at different proficiency levels (below/at/above grade level). The skill produces the following artifacts in Turn 1, all rendered from one master JSON via bundled scripts: * **1 teacher-facing differentiation plan** * **3 student-ready tier documents** The skill considers: * Source lesson identification from conversation history, uploads, or URLs * Subject-specific differentiation rules and document templates * Curriculum alignment when a curriculum is named or implied (e.g., IM® v.360) * Grounding in state-specific standards when jurisdiction signals are present * Grade-level demand across all tiers This skill works with or without Knowledge Graph, but we strongly recommend connecting to it. See [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) for more information. ## At a glance | | | | :------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Workflow** | Differentiate an existing lesson into below/at/above proficiency tiers | | **Subjects** | Math, ELA, Science, Social Studies | | **Supported grades** | K–12 | | **Rubrics** | | ## Getting started Follow the [Quickstart](/agent-skills/getting-started/quickstart) to start using this skill: | Access method | | | :---------------------- | :-------------------------------------------------------------------------------------------------------------------------------------- | | **Knowledge Graph MCP** | [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) | | **Example prompts** | [example-prompts.md](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md#lesson-differentiation) ↗ | | **Skill instructions** | [`SKILL.md`](https://github.com/learning-commons-org/agent-skills/blob/main/skills/k12-lesson-differentiation/SKILL.md) ↗ | ## Triggers Your LLM will programmatically load this skill when explicitly or implicitly prompted to differentiate, tier, or scaffold an existing K-12 lesson: * **Explicitly**: "differentiate this lesson," "tier for below/at/above," "scaffold for struggling and advanced students" * **Implicitly**: "my students are at different levels," "I have struggling and advanced students" ## Output | Artifact | Description | | :-------------------------------------- | :--------------------------------------------------------------------------- | | **Teacher-facing differentiation plan** | Plan explaining tier design, preserved core content, and scaffolding choices | | **Below-level student materials** | Tier with scaffolding that preserves grade-level standard demand | | **At-level student materials** | On-grade tier aligned to the source lesson | | **Above-level student materials** | Extension tier with increased depth or complexity | | **Rendered files** | Editable `.docx` Word documents on confirmation | ## Scoring 1. Generate differentiated materials using this skill. 2. Apply `differentiation.csv` to the tiered artifacts and `clarifying_question.csv` to evaluate the model's pre-generation clarification behavior. 3. Run LLM-as-judge or human review against each criterion. See [Evaluating outputs](/agent-skills/using-agent-skills/evaluating-outputs). ## Skill release history | Date | Changed | | ------------- | ------------------------------------------ | | July 14, 2026 | First release, co-developed with Anthropic | ## Related topics Explore available Agent Skills and their published evaluation rubrics. Learn how skills, rubrics, and the P/R/O/M framework work together. # K-12 Lesson Plan Creation Source: https://docs.learningcommons.org/agent-skills/skills/k12-lesson-plan-creation Reference for the K-12 Lesson Plan Creation skill, which generates standards-aligned lesson plans, student materials, and observation templates. [Skill last updated July 14, 2026](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-plan-creation) The K-12 Lesson Plan Creation Agent Skill was co-developed with [Anthropic](https://www.anthropic.com/) ↗. ## Overview The [K-12 Lesson Plan Creation](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-plan-creation) ↗ skill creates a lesson plan, student-facing materials, and an observation template. It produces teacher-ready, standards-aligned artifacts as native files in Turn 1, rendered from one master JSON via bundled scripts (editable `.docx` Word documents on confirmation). The skill works with or without the Learning Commons Knowledge Graph. The skill considers: * Subject routing with mandatory subject reference files * Curriculum alignment when a curriculum is named or implied (e.g., IM® v.360) * Grounding in standards when connected to [Knowledge Graph](/knowledge-graph/) * Subject-specific pedagogy, grade-band structures, and output mappings This skill works with or without Knowledge Graph, but we strongly recommend connecting to it. See [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) for more information. ## At a glance | | | | :------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Workflow** | Create a new standards-aligned lesson from scratch | | **Subjects** | Math, ELA, Science, Social Studies | | **Supported grades** | K–12 | | **Rubrics** | | ## Getting started Follow the [Quickstart](/agent-skills/getting-started/quickstart) to start using this skill: | Access method | | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------- | | **Knowledge Graph MCP** | [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) | | **Example prompts** | [example-prompts.md](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md#lesson-planning) ↗ | | **Skill instructions** | [`SKILL.md`](https://github.com/learning-commons-org/agent-skills/blob/main/skills/k12-lesson-plan-creation/SKILL.md) ↗ | ## Triggers Your LLM will programmatically load this skill when explicitly or implicitly prompted to build a K-12 lesson for a particular topic or standard from scratch: * **Explicitly**: "math lesson plan," "mini-lesson," "unit plan," "reading lesson," "phonics lesson" * **Implicitly**: "I'm teaching long division to 5th graders," "planning a lesson on RL.4.3 next week," "need to teach photosynthesis tomorrow" ## Output | Artifact | Description | | :----------------------------- | :--------------------------------------------------------------------------------- | | **Teacher-facing lesson plan** | Standards-aligned plan with subject-specific structure and teacher rationale notes | | **Student-facing materials** | Materials appropriate for the lesson's grade band and subject pedagogy | | **Observation template** | Template for classroom observation aligned to the lesson structure | | **Rendered files** | Editable `.docx` Word documents on confirmation | ## Scoring Apply `shared.csv` first, then layer in the subject-specific file. For example, score a 7th grade ELA lesson against `shared.csv` and `ela.csv`. 1. Generate lesson materials using this skill. 2. Select `shared.csv` plus the subject-specific rubric that matches the lesson. 3. Run LLM-as-judge or human review against each criterion. See [Evaluating outputs](/agent-skills/using-agent-skills/evaluating-outputs). ## Skill release history | Date | Changed | | ------------- | ------------------------------------------ | | July 14, 2026 | First release, co-developed with Anthropic | # K-12 Lesson Prep Source: https://docs.learningcommons.org/agent-skills/skills/k12-lesson-prep Reference for the K-12 Lesson Prep skill, which helps teachers internalize an existing lesson through guided analysis of sample student work. [Skill last updated August 28, 2026](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-prep) The K-12 Lesson Prep Agent Skill was co-developed with [Anthropic](https://www.anthropic.com/) ↗. ## Overview The [K-12 Lesson Prep](https://github.com/learning-commons-org/agent-skills/tree/main/skills/k12-lesson-prep) ↗ skill helps a teacher prepare for, and internalize, an existing lesson before teaching it: * Build mastery of what's important about the lesson and why * Anticipate how to distinguish between student mastery and a need for more support * Walk into class confident in their understanding of the lesson's content and focus This skill's output is not a rendered file – it is the conversation itself. The skill presents the teacher one small piece of student work at a time, then waits for the teacher's read before offering its own. A short teacher-only prep note may be produced at the end, but this is a byproduct of the conversation, not the point of it. This skill works with or without Knowledge Graph, but we strongly recommend connecting to it. See [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) for more information. ## At a glance | | | | :------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Workflow** | Internalize an existing lesson through conversation before teaching it | | **Subjects** | Math, ELA, Science, Social Studies | | **Supported grades** | K–12 | | **Rubrics** | | ## Getting started Follow the [Quickstart](/agent-skills/getting-started/quickstart) to start using this skill: | Access method | | | :---------------------- | :--------------------------------------------------------------------------------------------------------------------------- | | **Knowledge Graph MCP** | [Quickstart: Connect Knowledge Graph](/agent-skills/getting-started/quickstart#connect-knowledge-graph) | | **Example prompts** | [example-prompts.md](https://github.com/learning-commons-org/agent-skills/blob/main/skills/example-prompts.md#lesson-prep) ↗ | | **Skill instructions** | [`SKILL.md`](https://github.com/learning-commons-org/agent-skills/blob/main/skills/k12-lesson-prep/SKILL.md) ↗ | ## Triggers Your LLM will programmatically load this skill when explicitly or implicitly prompted to prepare to teach a specific lesson that already exists: * **Explicitly**: "prep me for tomorrow's lesson," "get me ready to teach this" * **Implicitly**: "I'm teaching this lesson tomorrow and want to feel ready," "what should I be watching for when I teach this," "help me get ready for class" ## Output | Artifact | Description | | :---------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Conversation itself** | Primary output: a turn-by-turn walkthrough of the lesson's near-miss vs. proficient student work, its highest-leverage sticking points, and how to respond without de-rigoring the material | | **Optional teacher-only prep note** | A short, scannable note in the lesson's own teaching order, produced only on request or at the natural end of the conversation | ## Scoring 1. Run a lesson prep conversation using this skill. 2. Apply `shared.csv` plus `confirmation_bias.csv` and `student_work_first.csv`, which evaluate conversational behavior rather than a finished artifact. 3. Run LLM-as-judge or human review against each criterion. See [Evaluating outputs](/agent-skills/using-agent-skills/evaluating-outputs). ## Skill release history | Date | Changed | | --------------- | ------------------------------------------ | | August 28, 2026 | First release, co-developed with Anthropic | # Core concepts Source: https://docs.learningcommons.org/agent-skills/understanding-agent-skills/core-concepts Key Agent Skills concepts, including SKILL.md files, reference files, evaluation rubrics, and the P/R/O/M quality framework for K-12 outputs. ## How Agent Skills are designed | Concept | Definition | | :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Skill](#skill)

| A folder containing a `SKILL.md` file with metadata and step-by-step instructions that tell an agent how to complete a specific K-12 teaching workflow.
**Example:** The [K-12 Lesson Plan Creation](/agent-skills/skills/k12-lesson-plan-creation) skill routes by subject, grounds in standards, and renders classroom-ready artifacts from a master JSON file. | |

[Reference files](#reference-files)

| Subject-specific markdown files bundled with each skill that carry pedagogy, curriculum branching, grade-band structures, and output mappings.
**Example:** A math lesson loads `references/math.md` before drafting; skipping this step is treated as a critical failure. | |

[Bundled scripts](#bundled-scripts)

| Helper scripts included with each skill to render editable `.docx` Word documents from structured JSON output.
**Example:** Both lesson skills render teacher plans and student materials from one master JSON via shared render scripts. | |

[Knowledge Graph MCP Server](/knowledge-graph/using-knowledge-graph/mcp-server)

| Optional MCP tools that let Agent Skills resolve standards, learning components, progressions, and curriculum context at runtime.
**Example:** When connected, the skill calls `find_standard_statement` before drafting; when not connected, it falls back to general knowledge with a disclosure footer. | ## How quality is evaluated | Concept | Definition | | :------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Rubrics](#rubrics)

| A CSV of scoreable criteria used to benchmark the quality of skill outputs. Each criterion includes a pass condition, optional conditionality, and design notes.
**Example:** Lesson planning rubrics include `shared.csv` plus subject-specific files such as `math.csv` and `ela.csv`. | |

[P/R/O/M framework](#the-p-r-o-m-framework)

| All criteria fall into one of four buckets. The buckets reflect two paired goals: **quality** (does the output reflect strong pedagogy and appropriate rigor?) and **usability** (is the output formatted and scaffolded in a way that a real teacher can actually use it?).

P — Pedagogy — Pedagogy criteria evaluate whether the output reflects sound instructional design: standards alignment, prerequisite and forward connections, appropriate instructional model, discourse structures, attention to student struggle, and visual/representational choices.

Key pedagogical commitments:R — Rigor — Rigor criteria evaluate whether the output maintains grade-level cognitive demand:O — Output/Formatting — Output criteria evaluate the artifact itself: correct file structure, appropriate length, teacher- vs. student-facing separation, universal design features, and teacher rationale notes.

One criterion worth calling out: designed for teacher adaptation. Teacher-facing outputs should note which elements are non-negotiable and why.

M — Model Scaffolding — Model Scaffolding criteria evaluate the model's conversational behavior: whether it asks for missing information before generating, whether it proactively produces student-facing materials, and whether it offers meaningful follow-up options. | |

[LLM as judge](#llm-as-judge)

| An evaluation method where an LLM scores generated materials against rubric criteria as pass/fail, with explanations.
Learning Commons publishes rubrics openly so developers can reuse the same quality bar in their own evaluator harnesses. | |

[Conditional criterion](#conditional-criterion)

| A rubric criterion that applies only when a specified condition is met (for example, `K-5` or `ELA-Gr8+`). If the condition isn't met, the criterion is skipped — not failed. | ## How Agent Skills relate to other tools | Tool | Relationship | | :--------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Knowledge Graph**](/knowledge-graph/understanding-knowledge-graph/introduction) | Supplies standards, learning components, progressions, and curriculum data that skills draw on through MCP tools. Strongly recommended for accurate outputs. | | [**Evaluators**](/evaluators/understanding-evaluators/introduction) | Measure AI output quality using rubrics for [Student-Facing Text](/evaluators/student-facing-text-evaluators/introduction) complexity, [Feedback](/evaluators/feedback-evaluators/introduction) quality, and [Standards](/evaluators/standards-evaluators/introduction) alignment (includes evaluators, rubrics, and related tooling). Agent Skills evaluation rubrics focus specifically on K-12 instructional artifact quality. | ## Related topics Explore available Agent Skills and their published evaluation rubrics. Benchmark skill outputs against rubrics with LLM-as-judge or human review. # Introduction Source: https://docs.learningcommons.org/agent-skills/understanding-agent-skills/introduction What Agent Skills are and how they help AI assistants generate standards-aligned K-12 teaching materials grounded in learning science. Skill instructions, rubrics, and example prompts live in the [`agent-skills`](https://github.com/learning-commons-org/agent-skills) ↗ GitHub repository. ## What Agent Skills do Agent Skills are open, ready-to-use skills that help AI assistants produce high-quality, standards-aligned instructional materials for teachers. Edtech developers and school district technologists can use Agent Skills to plan and differentiate lessons for teachers. | Skill | Description | Development partner | | :----------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------- | | [**K-12 Check for Understanding**](/agent-skills/skills/k12-check-for-understanding) | Generates a short, targeted math Check for Understanding (typically 1–3 items) that surfaces what a student currently understands about a specific standard. | [Anthropic](https://www.anthropic.com/) ↗ and [Student Achievement Partners](https://learnwithsap.org/research-grounded-products/) ↗ | | [**K-12 Lesson Differentiation**](/agent-skills/skills/k12-lesson-differentiation) | Adapts an existing lesson into tiered versions (below / at / above proficiency level) and for specific student needs, keeping core content consistent across tiers. | [Anthropic](https://www.anthropic.com/) ↗ | | [**K-12 Lesson Plan Creation**](/agent-skills/skills/k12-lesson-plan-creation) | Builds classroom-ready, standards-aligned lesson plans, optionally aligned to a teacher's curriculum. | [Anthropic](https://www.anthropic.com/) ↗ | | [**K-12 Lesson Prep**](/agent-skills/skills/k12-lesson-prep) | Helps a teacher internalize an existing lesson through conversation — anticipate where students will get stuck and get ready to respond in the moment. | [Anthropic](https://www.anthropic.com/) ↗ | Agent Skills are grounded in learning science and can leverage [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction) to produce standards-aligned results. Explore [Use cases](/agent-skills/understanding-agent-skills/use-cases) for Agent Skills when developing edtech products or streamlining district and classroom workflows. ## How to access Agent Skills Agent Skills are cross-platform and model-agnostic. They can be used with any agent runtime that supports the [open Agent Skills format](https://agentskills.io/) ↗: * Claude Code * Cursor * Codex Check out the [GitHub repository](https://github.com/learning-commons-org/agent-skills) ↗ to inspect skill instructions, reference files, scripts, and rubrics directly. ## Our approach Our initial set of Agent Skills and evaluation rubrics was co-developed with [Anthropic](https://www.anthropic.com/) ↗. These skills don't just generate plausible-looking materials — they're grounded in research-backed principles and refined with expert practitioners. | Principle | Description | | :------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Pedagogy** | Outputs reflect sound instructional design. | | **Rigor** | Outputs maintain grade-level cognitive demand | | **Usability** | Outputs are classroom-ready and default to universal design | ## Related topics Explore product, district, and classroom workflows for Agent Skills. Learn how skills, rubrics, and the P/R/O/M framework work together. Install skills, connect Knowledge Graph, and try example prompts. # Use cases Source: https://docs.learningcommons.org/agent-skills/understanding-agent-skills/use-cases Common ways to use Agent Skills, from shipping lesson planning features and district AI assistants to benchmarking instructional quality. These are several common ways that edtech teams use Agent Skills in product development and in district and classroom workflows. | Use case | Description | Examples | | :---------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- | | **Ship teacher-facing features** | Ship lesson planning and differentiation features in your edtech application without re-inventing pedagogy prompts or rubrics. | Embed K-12 Lesson Plan Creation into a product workflow so teachers get classroom-ready plans on demand. | | **Offer standards-aligned materials at the district level** | Deploy Agent Skills inside internal AI assistants at the district level to provide standards-aligned outputs to all teachers by default. | Add K-12 Lesson Differentiation to a district assistant that adapts existing lessons for mixed classrooms. | | **Plan standards-aligned lessons** | Generate classroom-ready lesson plans with teacher-facing plans, student materials, and observation templates. | A 3rd grade teacher needs a lesson on rounding to the nearest hundred for tomorrow. | | **Differentiate existing lessons** | Adapt a lesson into below / at / above proficiency tiers while preserving core content and grade-level demand. | A 6th grade teacher wants tiered versions of a food webs lesson linked from an external curriculum site. | | **Ground outputs in trusted data** | Pair Agent Skills with [Knowledge Graph](/knowledge-graph/understanding-knowledge-graph/introduction) to resolve standards, learning components, progressions, and curriculum context. | Anchor a math lesson to state standards and Illustrative Mathematics structures. | | **Benchmark instructional quality** | Score generated materials against published [evaluation rubrics](/agent-skills/skills/introduction#rubrics) using LLM-as-judge or human review. | Validate that a lesson plan meets pedagogy, rigor, formatting, and model-scaffolding criteria. | ## Related topics Install skills, connect Knowledge Graph, and try example prompts. # Evaluating outputs Source: https://docs.learningcommons.org/agent-skills/using-agent-skills/evaluating-outputs How to evaluate Agent Skills outputs by selecting the right rubric CSV files and scoring with an LLM-as-judge prompt or human review. Once you've prompted your LLM to use an Agent Skill (e.g., [K-12 Lesson Plan Creation](/agent-skills/skills/k12-lesson-plan-creation)) and received an output (e.g., a lesson plan), you may want to evaluate the quality of this AI-generated output. ## Select rubrics Find the rubric files that match the skill and/or subject addressed in your prompt. | Skill | Rubric files | | :------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [K-12 Lesson Plan Creation](/agent-skills/skills/k12-lesson-plan-creation) | | | [K-12 Lesson Differentiation](/agent-skills/skills/k12-lesson-differentiation) | | | [K-12 Lesson Prep](/agent-skills/skills/k12-lesson-prep) | | | [K-12 Check for Understanding](/agent-skills/skills/k12-check-for-understanding) | | ## Evaluate output Pass your output materials (e.g., the AI-generated lesson plan) and selected rubrics (e.g., `shared.csv` and `ela.csv` for an English Language Arts lesson plan) to your LLM with the prompt below: ```txt theme={null} You are a rigorous educational content evaluator. Your job is to assess whether AI-generated lesson plan documents meet specific rubric criteria. You will receive: 1. The lesson-plan documents as attached files. 2. The model's final chat response (the text it sent back to the user). 3. A rubric with criteria to judge against. Grading rules: - Judge criteria in the `M` (Model Scaffolding) bucket against the chat response. Judge all other criteria against the attached documents. - The content must actually be present in the documents, not merely claimed in the chat response. - Pass means the criterion is clearly and fully met. Fail means it is absent, incomplete, or only partially met. Respond ONLY with a valid JSON array — no preamble, no markdown fences, no trailing text. Each element: { "id": "...", "pass": true|false, "explanation": "one sentence" } ``` Each rubric criterion will be scored independently as pass (`1`) or fail (`0`). ## Related topics Learn how Pedagogy, Rigor, Output, and Model Scaffolding criteria are organized. Find the rubric files that match each Agent Skill and subject. # Activities for a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/activities-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/activities Fetches summary information for all activities that address a specific academic standard. Returns activity summaries (identifier, name, position) that are aligned to this standard, indicating which specific instructional tasks help students achieve this learning expectation. Use this endpoint when you need to: - Find all activities that teach a specific standard - Build standards-based activity sets - Track standards coverage at the activity level - Generate detailed standards alignment reports # Assessments for a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/assessments-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/assessments Fetches summary information for all assessments that evaluate a specific academic standard. Returns assessment summaries (identifier, name) that are aligned to this standard, indicating which assessments measure student achievement of this learning expectation. Use this endpoint when you need to: - Find all assessments that evaluate a specific standard - Build standards-based assessment systems - Track which standards are assessed - Generate assessment coverage reports # Children of a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/children-of-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/children Fetches StandardsFrameworkItems that are direct children of the specified academic standard through the "hasChild" relationship. This endpoint retrieves academic standards that are hierarchically organized under the given academic standard. This allows you to navigate down the standards framework hierarchy from domains to clusters to individual academic standards, or from any parent grouping to its children. Use this endpoint when you need to: - Navigate down the standards framework hierarchy (e.g., from domain to academic standards) - Get all academic standards within a specific grouping or cluster - Build tree visualizations of standards framework structures - Explore the organizational structure of a standards document **Note:** This returns direct children only, not all descendants. To get all descendants, you'll need to traverse multiple levels. The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Understanding the hasChild relationship](/knowledge-graph/schema-reference/standards#haschild) # Lessons for a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/lessons-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/lessons Fetches summary information for all lessons that address a specific academic standard. Returns lesson summaries (identifier, name, position) that are aligned to this standard, indicating which lessons in the curriculum help students achieve this learning expectation. Use this endpoint when you need to: - Find all lessons that teach a specific standard - Build standards-based lesson sequences - Track where standards are addressed across the curriculum - Generate standards coverage reports # Prerequisites for a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/prerequisites-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/prerequisites Fetches the prerequisite StandardsFrameworkItems for the specified academic standard - the foundational standards it builds **from** via the "buildsTowards" relationship. These are the foundational skills or concepts that contribute to mastery of the given academic standard (each prerequisite `buildsTowards` the given standard). The relationship is directional but does not require strict prerequisite order - students don't need to fully master prerequisites before engaging with the given academic standard. Use this endpoint when you need to: - Identify foundational academic standards students should be familiar with before tackling a target academic standard - Trace backward through a learning progression to understand dependencies - Design remediation or review activities based on prerequisite skills - Map out a coherent learning pathway for students **Note:** Learning progression data is currently based on Student Achievement Partners' Coherence Map for Common Core State Standards (CCSS) for Mathematics. Coverage for other subjects and frameworks may be limited. The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Understanding the buildsTowards relationship](/knowledge-graph/schema-reference/learning-progressions#buildstowards) # Related standards for a standard Source: https://docs.learningcommons.org/api-reference/academic-standards/related-standards-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/related-standards Fetches StandardsFrameworkItems that are related to the specified academic standard through the "relatesTo" relationship. This endpoint retrieves academic standards that share meaningful conceptual or skill-based links with the given academic standard, without implying a specific sequence or prerequisite order. These lateral connections highlight associations that can inform instructional design, identify reinforcing concepts, or reveal thematic links across academic standards. Use this endpoint when you need to: - Find academic standards with related content or skills for integrated instruction - Identify opportunities for reinforcing concepts across different academic standards - Design cross-curricular or thematic units that connect related academic standards - Discover alternative pathways or parallel concepts in curriculum planning **Note:** Learning progression data is currently based on Student Achievement Partners' Coherence Map for Common Core State Standards (CCSS) for Mathematics. Coverage for other subjects and frameworks may be limited. The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Understanding the relatesTo relationship](/knowledge-graph/schema-reference/learning-progressions#relatesto) # Search standards Source: https://docs.learningcommons.org/api-reference/academic-standards/search-standards /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/search Searches for StandardsFrameworkItems using either semantic search or exact statement code match across all standards frameworks. This endpoint supports two mutually exclusive search modes: - **Semantic search** (`query`): Full-text semantic search against the standard's description. Results are ranked by relevance and include a `score` reflecting vector similarity. - **Code search** (`statementCode`): Exact statement code match (e.g., "3.NF.A.1"). Case-insensitive, no partial matching. All results carry a `score` of 1.0. **Exactly one of `query` or `statementCode` must be provided.** Providing both or neither returns a 400 error. Results can be narrowed further using the optional filters and support cursor-based pagination. Use this endpoint when you need to: - Find academic standards relevant to a concept or learning goal (semantic search) - Look up an academic standard by its exact statement code - Find all standards frameworks that include a specific statement code - Filter search results by grade level, subject, or statement type **Note:** Not all academic standards have statement codes - some organizational groupings may have null codes and won't appear in code search results. **Related topics:** - [Understanding statement codes](/knowledge-graph/schema-reference/standards#standardsframeworkitem) # Standard by ID Source: https://docs.learningcommons.org/api-reference/academic-standards/standard-by-id /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID} Fetches a single `StandardsFrameworkItem` by its CASE Network UUID. A `StandardsFrameworkItem` represents an individual statement or structural element within a standards framework. These items can be normative statements that specify what students should know or be able to do (e.g., "Describe the impact of a transformation matrix on a graphical object"), or organizational groupings that structure the framework (e.g., domains, strands, clusters). Use this endpoint when you need to: - Display the full details of a specific academic standard in your application - Retrieve the exact statement text, grade levels, and classification for a known academic standard - Trace an academic standard back to its source in the CASE Network via the CASE identifiers The response includes the statement text, grade level(s), subject area, jurisdiction, and all source attribution required by the CC BY 4.0 license. **Related topics:** - [Understanding StandardsFrameworkItem vs StandardsFramework](/knowledge-graph/schema-reference/standards) - [Standard classification types](/knowledge-graph/schema-reference/enums-and-formats#normalizedstatementtypeenum) # Standards a standard builds towards Source: https://docs.learningcommons.org/api-reference/academic-standards/standards-a-standard-builds-towards /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/builds-towards Fetches the StandardsFrameworkItems that the specified academic standard builds **towards** via the "buildsTowards" relationship - the standards it is a prerequisite of. These are the next logical learning steps or more advanced concepts that students can progress to after working with the given academic standard (the given standard `buildsTowards` each of them). Proficiency in the given academic standard supports the likelihood of success in these standards. Use this endpoint when you need to: - Identify next steps in a learning progression after students master an academic standard - Design curriculum sequences that build on foundational skills - Map forward through learning pathways to understand where academic standards lead - Plan long-term instructional trajectories for students **Note:** Learning progression data is currently based on Student Achievement Partners' Coherence Map for Common Core State Standards (CCSS) for Mathematics. Coverage for other subjects and frameworks may be limited. The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Understanding the buildsTowards relationship](/knowledge-graph/schema-reference/learning-progressions#buildstowards) # Standards frameworks Source: https://docs.learningcommons.org/api-reference/academic-standards/standards-frameworks /api-reference/knowledge-graph-api/openapi.yaml get /standards-frameworks Fetches a list of StandardsFramework objects representing complete academic standards documents. Each standards framework represents a complete standards document published by an official body like a state department of education. This endpoint allows you to discover available standards frameworks and retrieve metadata about standards documents from different jurisdictions, subjects, and adoption statuses. Use this endpoint when you need to: - Discover available standards frameworks to query academic standards from - Find standards framework UUIDs needed for the GET /academic-standards endpoint - Browse standards frameworks by subject, jurisdiction, or adoption status - Get standards framework metadata (title, adoption status, modification dates) **Related topics:** - [Understanding StandardsFramework vs StandardsFrameworkItem](/knowledge-graph/schema-reference/standards) - [Framework adoption statuses](/knowledge-graph/schema-reference/enums-and-formats#adoptionstatusenum) # Standards in a framework Source: https://docs.learningcommons.org/api-reference/academic-standards/standards-in-a-framework /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards Fetches a list of StandardsFrameworkItems for a specific standards framework. This endpoint retrieves academic standards from a single standards framework identified by its CASE Network UUID. You can further filter the results by grade level or classification type. This is useful when you need to work with academic standards from a specific state or jurisdiction. Use this endpoint when you need to: - Get all academic standards within a specific standards framework - Find academic standards for a particular grade level within a standards framework - Filter academic standards by subject area (e.g., only Mathematics academic standards) - Filter academic standards by their normalized classification (e.g., only instructional academic standards, not organizational groupings) - Retrieve a subset of a standards framework's academic standards for display or processing The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned and navigate through large result sets. **Related topics:** - [Understanding StandardsFrameworkItem classifications](/knowledge-graph/schema-reference/enums-and-formats#normalizedstatementtypeenum) # Activities in a lesson Source: https://docs.learningcommons.org/api-reference/curriculum/activities-in-a-lesson /api-reference/knowledge-graph-api/openapi.yaml get /lessons/{lessonId}/activities Fetches a list of activities within a specific lesson. An activity represents a discrete instructional task or exercise within a lesson, designed for students, teachers, or both. Activities are the building blocks of lessons and typically include specific tasks, exercises, discussions, or practice problems that help achieve the lesson's learning objectives. Use this endpoint when you need to: - Get all activities for a specific lesson - Navigate the instructional components of a lesson - Access activity metadata including timing, grouping, and submission requirements - Build lesson plans or instructional sequences # Assessments in a course Source: https://docs.learningcommons.org/api-reference/curriculum/assessments-in-a-course /api-reference/knowledge-graph-api/openapi.yaml get /assessments Fetches assessments for a course with optional filtering by lesson or lesson grouping. Assessments can be associated with different levels of the curriculum hierarchy: - **Course-level**: All assessments in the course - **Lesson grouping-level**: Assessments for a unit, section, or module (e.g., "End-of-Unit Assessment") - **Lesson-level**: Assessments specific to a lesson Use this endpoint when you need to: - Get all assessments for a course - Find assessments for a specific lesson grouping (unit, section, module) - Find assessments for a specific lesson - Build assessment reports or tracking systems **Note:** You cannot provide both `lessonId` and `lessonGroupingId` in the same request. # Courses in a curriculum Source: https://docs.learningcommons.org/api-reference/curriculum/courses-in-a-curriculum /api-reference/knowledge-graph-api/openapi.yaml get /courses Fetches a list of Course objects for a specific curriculum. A Course consists of a structured sequence of instructional content and activities designed to teach specific skills, knowledge, or competencies over a defined period. It typically encompasses multiple lesson groupings, lessons, and activities and aligns with curriculum standards and intended learning objectives for a particular grade level or subject area. Use this endpoint when you need to: - Discover available courses within a curriculum - Get course metadata (name, description, grade levels, subject) - Find course identifiers needed for other curriculum endpoints Currently, im360 is the only valid value for the curriculumId parameter. # Dependency map for a curriculum Source: https://docs.learningcommons.org/api-reference/curriculum/dependency-map-for-a-curriculum /api-reference/knowledge-graph-api/openapi.yaml get /curriculums/{curriculumId}/dependency-map Returns the dependency relationships between lesson groupings within a curriculum. Dependencies represent prerequisite relationships between lesson groupings (units, sections, modules). A dependency from source → target means the target is a prerequisite — it should be taught before the source. Use this endpoint when you need to: - Visualize the dependency graph for a curriculum - Understand prerequisite relationships between units or sections - Build a dependency-aware course planner or sequencing tool # Lesson by ID Source: https://docs.learningcommons.org/api-reference/curriculum/lesson-by-id /api-reference/knowledge-graph-api/openapi.yaml get /lessons/{lessonId} Fetches detailed information about a specific lesson. A lesson represents a focused instructional session within a larger curriculum structure, such as a lesson grouping or course, designed to achieve specific learning objectives. It typically includes activities, discussions, and assessments, and is intended to be completed within a defined timeframe, such as a class period or session. Use this endpoint when you need to: - Get complete metadata for a specific lesson - Retrieve lesson details including timing, audience, and educational use - Access curriculum-specific labeling information - Understand a lesson's place in the course structure # Lesson grouping by ID Source: https://docs.learningcommons.org/api-reference/curriculum/lesson-grouping-by-id /api-reference/knowledge-graph-api/openapi.yaml get /lesson-groupings/{groupingId} Fetches detailed information about a specific lesson grouping. Set of related lessons within a curriculum; naming and organizational level may vary across curricula (e.g., unit, module, chapter, section, theme). The `groupName` property indicates the specific type used by the curriculum. Lesson groupings can be nested (e.g., units containing sections, chapters containing modules) as indicated by the `groupLevel` property, where 0 represents the top level. Use this endpoint when you need to: - Get complete metadata for a specific lesson grouping - Retrieve organizational details (group name, level, position) - Access curriculum-specific labeling and structure information - Understand a lesson grouping's place in the course hierarchy # Scope and sequence for a course Source: https://docs.learningcommons.org/api-reference/curriculum/scope-and-sequence-for-a-course /api-reference/knowledge-graph-api/openapi.yaml get /courses/{courseId}/scope-and-sequence Returns the complete hierarchical structure of a course including its lesson groupings and lessons in a scope and sequence format. The structure follows this hierarchy: - Course → Lesson Groupings (can be nested) → Lessons **Note:** Different curricula use different organizational structures. Lesson groupings might be called units, modules, chapters, sections, themes, etc. depending on the curriculum. The `groupName` property in each lesson grouping indicates what type it is (e.g., "unit", "section", "module"). Use this endpoint when you need to: - Display the complete course outline or table of contents - Navigate the course structure programmatically - Build a course curriculum map or scope and sequence view - Understand the full instructional progression of a course The `view` parameter controls the level of detail: - `summary`: Returns only essential navigation fields (identifiers, names, positions) - `full`: Returns complete objects with all properties for each element # Standards for a lesson Source: https://docs.learningcommons.org/api-reference/curriculum/standards-for-a-lesson /api-reference/knowledge-graph-api/openapi.yaml get /lessons/{lessonId}/standards Fetches all academic standards aligned to a specific lesson. Returns the standards that this lesson addresses through its instructional content and activities. These alignments indicate which learning expectations the lesson is designed to help students achieve. Use this endpoint when you need to: - See which standards a lesson addresses - Build standards-aligned lesson plans - Track standards coverage across lessons - Generate standards-based reports # Standards for an activity Source: https://docs.learningcommons.org/api-reference/curriculum/standards-for-an-activity /api-reference/knowledge-graph-api/openapi.yaml get /activities/{activityId}/standards Fetches all academic standards aligned to a specific activity. Returns the standards that this activity addresses. These alignments indicate which learning expectations the activity is designed to help students achieve through specific tasks and exercises. Use this endpoint when you need to: - See which standards an activity addresses - Build standards-aligned activities - Track standards coverage at the activity level - Generate detailed standards-based reports # Standards for an assessment Source: https://docs.learningcommons.org/api-reference/curriculum/standards-for-an-assessment /api-reference/knowledge-graph-api/openapi.yaml get /assessments/{assessmentId}/standards Fetches all academic standards aligned to a specific assessment. Returns the standards that this assessment evaluates. These alignments indicate which learning expectations the assessment is designed to measure. Use this endpoint when you need to: - See which standards an assessment evaluates - Build standards-aligned assessments - Track standards coverage in assessments - Generate assessment standards reports # Children of a durable skill Source: https://docs.learningcommons.org/api-reference/durable-skills/children-of-a-durable-skill /api-reference/knowledge-graph-api/openapi.yaml get /durable-skills/{identifier}/children Fetches the direct children of a durable skill through the "hasChild" relationship. Durable skills frameworks are hierarchical, and this endpoint walks one level at a time. Check the parent's `hasChildren` flag before calling to avoid requests that return empty pages. Use this endpoint when you need to: - Navigate a framework's hierarchy one level at a time - Retrieve the progression levels beneath a skill - Build an expandable tree view of a framework **Related topics:** - [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) - [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) # Durable skill by ID Source: https://docs.learningcommons.org/api-reference/durable-skills/durable-skill-by-id /api-reference/knowledge-graph-api/openapi.yaml get /durable-skills/{identifier} Fetches a single DurableSkill by its Knowledge Graph identifier. Use this endpoint when you need to: - Retrieve the full details of a specific durable skill - Resolve an identifier returned by GET /durable-skills or the search endpoint Framework identifiers are not valid here — use GET /durable-skills-frameworks for frameworks. **Related topics:** - [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) - [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) # Durable skills frameworks Source: https://docs.learningcommons.org/api-reference/durable-skills/durable-skills-frameworks /api-reference/knowledge-graph-api/openapi.yaml get /durable-skills-frameworks Fetches the list of DurableSkillsFramework objects available in the knowledge graph. Durable skills frameworks describe transferable competencies — collaboration, communication, critical thinking and similar — rather than subject-area academic content. They are published outside the CASE Network, so they carry no CASE identifiers and are addressed by their Knowledge Graph `identifier`. Use this endpoint when you need to: - Discover which durable skills frameworks are available - Find the framework `identifier` required by GET /durable-skills - Get framework metadata (name, description, publisher, modification dates) Retired frameworks are excluded by default. Set `includeNonCurrent=true` to include them. **Related topics:** - [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) - [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) # Durable skills in a framework Source: https://docs.learningcommons.org/api-reference/durable-skills/durable-skills-in-a-framework /api-reference/knowledge-graph-api/openapi.yaml get /durable-skills Fetches a list of DurableSkill objects within a specific durable skills framework. Returns every item in the framework's hierarchy, from top-level skills through to the most granular progression levels. Use `normalizedStatementType` to retrieve only skill statements and exclude the organizational groupings that structure them. Use this endpoint when you need to: - Retrieve the full contents of a durable skills framework - Export a framework's skills for mapping to your own content - Browse a framework's structure before navigating it with /durable-skills/{identifier}/children **Related topics:** - [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) - [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) # Search durable skills Source: https://docs.learningcommons.org/api-reference/durable-skills/search-durable-skills /api-reference/knowledge-graph-api/openapi.yaml get /durable-skills/search Searches for DurableSkill objects by semantic similarity or by exact statement code. Provide exactly one of `query` or `statementCode`. Semantic search ranks results by relevance to the query text and returns a `score` reflecting vector similarity. Statement code search performs an exact, case-insensitive match and returns a score of 1.0. Use this endpoint when you need to: - Find durable skills relevant to a teaching goal or observed behaviour - Look up a specific skill by the code used in framework documentation - Discover skills to map to your own content or assessments Semantic search covers all durable skills frameworks. **Related topics:** - [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) - [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) # Learning component by ID Source: https://docs.learningcommons.org/api-reference/learning-components/learning-component-by-id /api-reference/knowledge-graph-api/openapi.yaml get /learning-components/{identifier} Fetches a single LearningComponent by its unique identifier. A LearningComponent represents a single, well-defined skill or concept that students are expected to learn. Learning components are granular units of learning that break down broad state standards into teachable and measurable parts at the level of a lesson, activity, or assessment question. Use this endpoint when you need to: - Display the full details of a specific learning component - Retrieve the skill description and metadata for a known learning component - Access attribution information for learning components used in your application Learning components(LCs) are developed through expert-driven processes with input from experienced educators. Currently, LCs are available for mathematics standards across multiple states, with more subjects and states being added over time. **Related topics:** - [Understanding learning components](/knowledge-graph/schema-reference/learning-components) - [LC creation and alignment process](/knowledge-graph/schema-reference/learning-components#creation-of-lcs) - [Available LC mappings by state](/knowledge-graph/schema-reference/learning-components#current-lc-mappings) # Learning components by subject Source: https://docs.learningcommons.org/api-reference/learning-components/learning-components-by-subject /api-reference/knowledge-graph-api/openapi.yaml get /learning-components Fetches a list of LearningComponents filtered by academic subject. This endpoint retrieves learning components for a specific subject area. Learning components are granular skills that break down broad standards into teachable units. Learning components are available for Mathematics and English Language Arts, with additional subjects being developed. Use this endpoint when you need to: - Get all learning components available for a specific subject - Browse the complete set of skills/concepts for curriculum planning - Retrieve LCs for mapping to your own content or assessments - Export learning component data for analysis or integration The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned and navigate through large result sets. **Related topics:** - [Understanding Learning components](/knowledge-graph/schema-reference/learning-components) - [Available LC coverage by subject and state](/knowledge-graph/schema-reference/learning-components#current-lc-mappings) # Learning components for a standard Source: https://docs.learningcommons.org/api-reference/learning-components/learning-components-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/learning-components Fetches a list of LearningComponents that support a specific StandardsFrameworkItem. This endpoint retrieves all learning components that are aligned to a given academic standard through the "supports" relationship. Learning components break down broad academic standards into granular, teachable skills, making them actionable for lesson planning and assessment design. Use this endpoint when you need to: - Find the specific skills that compose a given academic standard - Identify granular learning targets for instruction aligned to an academic standard - Map learning components to your curriculum or assessment items - Understand how a broad academic standard breaks down into teachable units **Note:** Learning component alignments are currently available primarily for Mathematics academic standards. Academic standards in other subjects or certain special categories (e.g., Standards for Mathematical Practice, Pre-K, advanced math) may not have LC alignments. The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Understanding the supports relationship](/knowledge-graph/schema-reference/learning-components#supports) - [LC alignment methodology](/knowledge-graph/schema-reference/learning-components#creation-of-lcs) - [Available LC coverage by state](/knowledge-graph/schema-reference/learning-components#current-lc-mappings) # Search learning components Source: https://docs.learningcommons.org/api-reference/learning-components/search-learning-components /api-reference/knowledge-graph-api/openapi.yaml get /learning-components/search This endpoint is for free-text semantic search across learning component descriptions. To retrieve learning components for a specific standard, use [Components for a standard](/api-reference/learning-components/learning-components-for-a-standard) instead. Searches for LearningComponents using semantic search against learning component descriptions. Results are ranked by relevance to the query text and include a `score` reflecting vector similarity. Use the optional `academicSubject` filter to narrow results to a specific subject area. Use this endpoint when you need to: - Find learning components relevant to a specific skill or concept - Discover granular instructional targets related to a teaching goal - Search for LCs to map to your own content or assessments **Related topics:** - [Understanding Learning components](/knowledge-graph/schema-reference/learning-components) - [Available LC coverage by subject and state](/knowledge-graph/schema-reference/learning-components#current-lc-mappings) # Overview Source: https://docs.learningcommons.org/api-reference/platform-api/overview Overview of the Knowledge Graph API, including base URL, authentication, and endpoints for curriculum, standards, and learning components. The Learning Commons API provides programmatic access to Knowledge Graph data: ### [Standards](/knowledge-graph/schema-reference/standards) | Dataset | Description | REST API endpoints | | :--------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- | :------------------------------------------------------------------------------------ | | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) | Official learning expectations across U.S. states and subjects | [Academic standards](/api-reference/academic-standards/standards-frameworks) | | [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) | Similarity matches between state and CCSS standards | [Standards crosswalks](/api-reference/standards-crosswalks/crosswalks-for-a-standard) | | [English Language Development Standards Framework](/knowledge-graph/datasets/standards/english-language-development-standards-framework) | Official language development expectations for multilingual learners | [Academic standards](/api-reference/academic-standards/standards-frameworks) | | [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) | Durable-skill learner outcomes and competencies | [Durable skills](/api-reference/durable-skills/durable-skills-frameworks) | | [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) | Collaboration, Communication, and Critical Thinking | [Durable skills](/api-reference/durable-skills/durable-skills-frameworks) | ### [Learning components](/knowledge-graph/schema-reference/learning-components) | Dataset | Description | REST API endpoints | | :------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------- | :------------------------------------------------------------------------------------------- | | [Math learning components](/knowledge-graph/datasets/learning-components/math-learning-components) | Granular Math skills and concepts aligned to standards | [Learning components](/api-reference/learning-components/learning-components-for-a-standard) | | [ELA learning components](/knowledge-graph/datasets/learning-components/ela-learning-components) | Granular ELA skills and concepts aligned to standards | [Learning components](/api-reference/learning-components/learning-components-for-a-standard) | ### [Learning progressions](/knowledge-graph/schema-reference/learning-progressions) | Dataset | Description | REST API endpoints | | :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) | Prerequisite and successor relationships between math standards | | ### [Curriculum](/knowledge-graph/schema-reference/curriculum) | Dataset | Description | REST API endpoints | | :-------------------------------------------------------- | :-------------------------------------------------------------------- | :-------------------------------------------------------------- | | [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) | Open scope and sequence; gated instructional and assessment materials | [Curriculum](/api-reference/curriculum/courses-in-a-curriculum) | ### [Instructional guidance](/knowledge-graph/schema-reference/instructional-guidance) | Dataset | Description | REST API endpoints | | :-------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------- | :----------------- | | [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) | Learner factors and instructional strategies from Digital Promise® | Not yet supported | ## How to use the API | | | | :----------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | | **Base URL** | `https://api.learningcommons.org/knowledge-graph/v0` | | **Authentication** | [Generate an API key](https://platform.learningcommons.org/api-keys/) ↗ and include it in the request header as `x-api-key: YOUR_API_KEY` | ## Related topics Review entities, relationships, and property definitions for Standards. Review entities, relationships, and property definitions for Learning Components. Review entities, relationships, and property definitions for Curriculum. # Crosswalks for a standard Source: https://docs.learningcommons.org/api-reference/standards-crosswalks/crosswalks-for-a-standard /api-reference/knowledge-graph-api/openapi.yaml get /academic-standards/{caseIdentifierUUID}/crosswalks Fetches a list of standards that align to a specific standard through shared learning components. This endpoint retrieves crosswalk relationships bidirectionally: - **State standard → CCSS**: Pass in a state standard to get matching Common Core State Standards (CCSS) - **CCSS → State standards**: Pass in a Common Core State Standards (CCSS) standard to get matching state standards across jurisdictions Each crosswalk includes similarity metrics based on measurable overlap of learning components to help understand the strength and nature of the alignment. Crosswalks provide a scalable way to extend mappings between CCSS and state-specific frameworks without independent matching logic. By leveraging the LC superset, crosswalks show where standards converge in content coverage. Use this endpoint when you need to: - Find Common Core State Standards (CCSS) standards that align to a state standard for content adaptation - Find state standards that align to a Common Core State Standards (CCSS) standard across multiple jurisdictions - Understand the similarity between standards - Map content between Common Core and state frameworks - Analyze the degree of overlap between standards **Note:** Crosswalks are currently available for Mathematics and English Language Arts (ELA) standards in states where LC alignment exists. Math crosswalks cover grades K-12. ELA crosswalks cover grades K-2. Crosswalks are evidence-based (require at least one shared learning component). The endpoint returns paginated results. Use the `limit` and `cursor` parameters to control the number of results returned. **Related topics:** - [Standards crosswalks methodology](/knowledge-graph/schema-reference/standards#understanding-the-jaccard-score) # Introduction Source: https://docs.learningcommons.org/evaluators/academic-standards-evaluators/introduction Overview of Academic Standards evaluators that measure whether educational content is aligned to a standard's sub-skills, or learning components. ## The problem Academic standards define what students are expected to know at each grade level, and they shape curriculum, instruction, and assessment. Edtech developers align their products to these standards, but a standards tag is often a claim, not a guarantee: * **A standard is rarely a single skill** * Most bundle several sub-skills (i.e., [learning components](/knowledge-graph/schema-reference/learning-components)) * A question could address one learning component and ignore the rest for a given standard * **Standards vary by jurisdiction** * A skill emphasized in one framework may be scoped differently, or absent entirely, in another * Alignment has to be judged against the framework in question, not a generic notion of a standard Asking human experts to manually check educational content against every learning component, across a bank of hundreds of questions, does not scale. ## What we're building Our Academic Standards evaluators assess whether educational content aligns with a given standard's learning components. | Output | Description | | :-------------------------------------------- | :------------------------------------------------------------------------------------- | | **Fine-grained, component-level data** | Validates tagging and trust that an item measures the skill it claims to | | **Coverage maps** | Surface exactly which standards, and which learning components, a question bank covers | | **Reasoning and feedback for every judgment** | Gives actionable feedback on turning *looks aligned* into *is aligned* | Our evaluators judge whether a question aligns to standards at the [learning components](/knowledge-graph/schema-reference/learning-components) level: | Evaluator | Description | | :--------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------ | | [**Math Standards Alignment**](/evaluators/academic-standards-evaluators/math-standards-alignment)
| Judges whether a Math question aligns to Math standards in a supported jurisdiction | | **ELA Standards Alignment** Coming soon | Judges whether an ELA question aligns to standards in a supported jurisdiction | ## Related topics Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. Assess whether a math question aligns to a standard's learning components. Explore the standards frameworks available in Knowledge Graph. # Math Standards Alignment Source: https://docs.learningcommons.org/evaluators/academic-standards-evaluators/math-standards-alignment Check math questions against a standard's learning components to see which math skills they actually measure. Supports CCSS and all 50 state standards. [Evaluator last updated June 30, 2026.](#evaluator-release-history) ## Overview The Math Standards Alignment evaluator checks a math question against a standard's individual [learning components](/knowledge-graph/schema-reference/learning-components) — not just against the standard's label. It reports which of a standard's components the question actually measures. The Math Standards Alignment evaluator judges whether a question is the *right math* for a standard. The Math Visual Correctness evaluator (coming soon) judges whether a math visual is *mathematically correct*. ## At a glance | | | | :------------------- | :------------------------------------------------------------------------------------ | | **Inputs** | Math assessment question | | **Supported grades** | K–12 | | **Jurisdictions** | Multi-State / CCSS standards, for all 50 states and Washington, DC | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------ | | **Model used** | claude-haiku-4-5-20251001 | | **Temperature** | 0 (fixed) | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/academic-standards-alignment/mathematics/math-standards-alignment/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/academic-standards-alignment/mathematics/math-standards-alignment/system.txt) ↗, [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/academic-standards-alignment/mathematics/math-standards-alignment/user.txt) ↗, and [`coarse-filter-user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/academic-standards-alignment/mathematics/math-standards-alignment/coarse-filter-user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------------------------------------ | :------- | | **Math question** | Full assessment prompt/instructions students see, K–12 math | Yes | | **Jurisdiction** | Multi-State / CCSS, a state, or DC | Yes | | **Standard(s)** | One or more standard codes from the selected jurisdiction | Yes | | **Grade** | Filters the standards list | No | | **Coarse filter** | Pre-screens relevance before full evaluation, useful at scale | No | The evaluator supports 3 modes: | Mode | Description | | :---------------------- | :--------------------------------------------------------------------------------------------------------- | | **Single check** | One question against one standard | | **Batch evaluation** | Set of question-standard pairs (e.g., tagging validation), run as a full question × standard cross-product | | **By-grade evaluation** | Question bank against every standard for a grade, for whole-grade coverage analysis | Use **Batch** and **By-grade evaluation** to surface which standards (and which learning components) are fully, partially, or not covered by a given question bank. ## Output The evaluator reduces alignment to a binary judgment (plus rationale) per learning component, and is not validated for grading, assessment, or placement decisions. Treat outputs as directional signals, and keep a human in the loop – especially for borderline cases. | Field | Description | | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Statement code** | Academic standard evaluated | | **Learning components** | List of the academic standard's learning components

Each learning component includes:
  • Description: Description for each learning component
  • Reasoning: What each learning component requires, what the question asks, and why that is or is not aligned
  • Aligned: Whether each learning component and the question are aligned on the standard
  • Feedback: Revision guidance (when not aligned) or brief confirmation (when aligned) for each learning component
| | **Aligned count** | Number of learning components the question aligns to | | **Total count** | Total number of learning components for the standard | | **Coarse filtered** | Whether the standard was excluded by the coarse filter (Batch and By-grade evaluation modes only) | ## Interpreting results The evaluator assesses standards alignment based on how many of a standard's learning components a question meets (i.e., **Aligned count** / **Total count**). Users should interpret the counts while keeping in mind the learning components a question was meant to target. An **Aligned count** of 2 out of a **Total count** of 5 is ambiguous information on its own. If those 2 **Aligned count** learning components include the ones a question was meant to target, you can conclude the question is aligned. Otherwise, you can conclude the question is not aligned. **Example**: A question that asks students to find the area of a rectangle by multiplying its sides' lengths is commonly tagged to Common Core 3.MD.C.7. However, that question meets only one of the 4 learning components that make up that standard. At the parent-code level the question looks aligned; at the learning-component level, it covers a quarter of the standard. ## Evaluator release history | Date | Changes | | ------------- | ------------- | | June 30, 2026 | First release | ## Related topics Explore evaluators that assess content alignment to academic standards. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Introduction Source: https://docs.learningcommons.org/evaluators/dataset/introduction Learn what evaluator datasets are, how experts annotate them, and how to use these benchmarks to validate edtech content and guide research. Evaluator datasets have been rigorously annotated by domain experts to act as a replicable and transparent benchmark for edtech developers across the field. For example, the [Student-Facing Text dataset](./student-facing-text) has been annotated by literacy experts and practitioners to: * Codify expert judgment on text complexity * Validate the accuracy of [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) Use these evaluator datasets to guide product development, support research, and integrate best practices into your own edtech team's workflows. ## For more information If you’d like to chat with our team about the dataset, methodology, or future plans, you can get in touch with us at [support@learningcommons.org](mailto:support@learningcommons.org) ↗. ## Related topics Explore expert-annotated text complexity data for grades 3–4. Learn how evaluator datasets inform accuracy and validation. # Student-Facing Text Source: https://docs.learningcommons.org/evaluators/dataset/student-facing-text Access and understand the Student-Facing Text dataset used for evaluator development, including expert-annotated benchmark data for text complexity evaluation. [Look at the annotated data.](https://github.com/learning-commons-org/evaluators/tree/main/datasets) ↗ ## About the dataset The Student-Facing Text dataset contains high-quality text complexity annotations for the CommonLit Ease of Readability (CLEAR) Corpus by literacy and education experts. The CLEAR Corpus was produced by [CommonLit in collaboration with Georgia State University](https://www.commonlit.org/blog/introducing-the-clear-corpus-an-open-dataset-to-advance-research-28ff8cfea84a/) ↗ and released in December 2021. It comprises nearly 5000 publicly available excerpts, each mapped against dimensions including Flesch-Kincaid and BT Easiness (Bradley-Terry coefficient based on teacher ratings of the text). We expanded the dataset by scoring a subset of rows for dimensions in Student Achievement Partners (SAP)'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗. Our [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) use this dataset as a benchmark when assessing AI-generated content. We hope edtech developers can use it to complement their own literacy work as well. Our initial release in September 2025 focuses on Grades 3 and 4 across sentence structure and vocabulary, but we plan to expand to all grades and all dimensions of text complexity assessed through SAP's Qualitative Text Complexity rubric. ## Our process Our process for producing annotated data is as follows: * Filter the CLEAR corpus to an approximate grade 3-4 range using Flesch-Kincaid Grade Level. * Partner with literacy experts from SAP and Achievement Network (ANet) to score against dimensions in SAP's Rubric. * With SAP and ANet, establish a gold set of \~80 examples per grade with representation across the 4 tiers of text complexity (Slightly, Moderately, Very, and Exceedingly complex). * Use the gold set to test and qualify a cohort of educators with 2+ years of experience teaching English Language Arts (ELA) at the corresponding grade level. * Produce 200+ rows (50+ per complexity tier), calibrating annotator scores using the Dawid-Skene method. flowchart showing a high-level overview of the annotation process Finally, we package the dataset by mapping multiple dimensions of text complexity to the clear\_id column. This results in an annotated dataset that can be easily merged with the CLEAR corpus. ## Columns Last updated September 23, 2025 This list will be updated as we incorporate more text complexity dimensions. | Column | Definition | | :---------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **UID** | Unique identifier for each row. | | **Clear ID** | Identifier for texts based on the CLEAR corpus. This is not a unique identifier, as some texts were scored for multiple grades. | | **Grade** | Grade-level for which the text is scored. For example, if Grade=3 and Sentence Structure Complexity Score=Slightly Complex, then the text is Slightly Complex for a third-grade student (see overall project documentation for specific assumptions). | | **Flesch-Kincaid** | Flesch-Kincaid Grade Level score for the text, provided from the CLEAR corpus. | | **Text** | Text from the CLEAR corpus that was annotated. | | **Sentence score** | Overall annotator rating for sentence structure complexity. Takes the values slightly complex, moderately complex, very complex, and exceedingly complex. See the technical docs for additional details on these categories. | | **Sentence score rationale** | Annotators’ explanations for their sentence structure score. | | **Vocabulary score** | Overall annotator rating for vocabulary complexity. Takes the values slightly complex, moderately complex, very complex, and exceedingly complex. See overall project documentation for additional details on these categories. | | **Vocabulary score rationale** | Annotators’ explanations for their vocabulary score. | | **Tier 2 words** | Words that are commonly used in academic settings and are more complex than colloquial, or everyday language, and often have multiple meanings

**Example:** "There are eight planets in the Solar System. From closest to farthest from the Sun, they are: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune." Most planets (Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune) are Tier 2 words for Grade 3. | | **Tier 3 words** | Words that are limited to a specific domain or that are so rare that an avid reader would likely not encounter them in a lifetime

**Domain-specific example:** enzyme
**Rare unconventional example:** abecedarian | | **Archaic words** | Words, or uses of words that are not commonly used in modern conversational language

**Example**: "The jury retired to deliberate on their verdict." Using "retire" to mean "withdrawing to a private place" is an archaic use. | | **Other complex words** | Additional complex words for students of the grade level, as identified by annotators. | | **Background knowledge assumption** | LLM-generated information on the background knowledge that students of a particular grade are likely to have about a topic. Information was provided to annotators during the scoring process. See the overall project documentation for detailed methodology on how this was generated. | Receiving **Not Scored** for a given column means that the text was not annotated for that column. ## Limitations * Annotator coverage per item is limited; reported precision and agreement reflect this coverage. * Annotations in future updates will improve statistical reliability by increasing confidence, reducing variance, and stabilizing borderline cases. * Flesch–Kincaid grade estimates (based on sentence and word length) are heuristic and do not capture qualitative factors (e.g., conceptual difficulty, vocabulary sophistication, thematic maturity). * They are recorded as metadata and may be referenced in the evaluator prompt as one of multiple signals. * They are not the sole determinant of evaluator labels. ## Related topics Understand what evaluator datasets are and how they are used. Learn how evaluator datasets inform accuracy and validation. # Critical Thinking Source: https://docs.learningcommons.org/evaluators/durable-skills-evaluators/critical-thinking Rate a student's source-based argumentative essay (grades 8–10) for critical thinking across five indicators plus an Overall rating. [Evaluator last updated September 3, 2026.](#evaluator-release-history) ## Overview The Critical Thinking evaluator rates a student's source-based argumentative essay for critical thinking, treated as distinct from writing quality. Given the essay, the assignment prompt, and the source passage(s) the student was given, it returns a rating for 5 indicators: * Evidence strength * Synthesizing sources (if more than one source is provided) * Counterarguments * Facts over opinions * Drawing conclusions The evaluator also returns an "Overall" rating, with evidence and reasoning included for all ratings. ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Student essay, assignment prompt, source passage(s), and source count | | **Supported grades** | 8–10 | | **Rubric** | Project rubric adapted from the Carnegie Foundation / ETS Skills Progressions, informed by the SFF critical-thinking framework | The evaluator was built and validated using the model below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------------------------- | | **Model used** | Claude Opus 5, version-pinned (`claude-opus-5-20260723`) | | **Temperature** | Not configurable — Opus 5 accepts no sampling parameters | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | Not yet available (v0.1, early access) | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/durable-skills/ela-writing/critical-thinking/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/durable-skills/ela-writing/critical-thinking/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/durable-skills/ela-writing/critical-thinking/user.txt) ↗)
Schemas ([`input_schema.json`](https://github.com/learning-commons-org/evaluators/blob/main/evals/durable-skills/ela-writing/critical-thinking/input_schema.json) ↗ and [`output_schema.json`](https://github.com/learning-commons-org/evaluators/blob/main/evals/durable-skills/ela-writing/critical-thinking/output_schema.json) ↗) | ## Inputs | Input | Description | Required | | :-------------------- | :------------------------------------------------------------------------------------------------------- | :------- | | **Assignment text** | Writing prompt the student answered | Yes | | **Source passage(s)** | Source passage(s) shown to the student | Yes | | **Source count** | Number of source passages provided (rates "Synthesizing sources" only when there is more than 1 passage) | Yes | | **Essay text** | Student essay (200–800 words recommended) | Yes | ## Output | Field | Description | | :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------- | | **Indicators** | One entry per rated indicator — Synthesizing sources, Evidence strength, Counterarguments, Facts over opinions, Drawing conclusions | | **Indicator evidence** | Verbatim quote(s) from the essay per indicator, each with a short comment on what it demonstrates | | **Indicator reasoning** | Reasoning for the rating, written before the rating itself | | **Indicator rating** | 5-level scale: Not Evident, Exploring, Analyzing, Integrating, Extending | | **Overall reasoning** | Reasoning including the median arithmetic across the indicator ratings | | **Overall rating** | Headline Critical Thinking rating, same five-level scale | ## Interpreting results | Output | How to use | | :---------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Indicator rating + evidence/reasoning** | Formative signal on where an essay sits on a specific critical-thinking skill

**Example**: Flag essays that rate low on Counterarguments or Facts over opinions for targeted instruction; show the quotes so a teacher can check the rating | | **Overall rating** | Cohort- or portfolio-level signal on critical thinking, distinct from writing quality

**Example**: Research or program-level analysis of critical-thinking trends across a set of essays, rather than an individual grade | ## Evaluator release history | Date | Changed | | ----------------- | ------------- | | September 3, 2026 | First release | ## Related topics Explore evaluators that rate student work against a construct's indicators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Introduction Source: https://docs.learningcommons.org/evaluators/durable-skills-evaluators/introduction Overview of Durable Skills evaluators that rate student work against a construct's indicators, with evidence and rationale for every judgment. ## The problem Constructs like critical thinking, argumentation, or reasoning are core to what schools want students to develop, and they shape rubrics, feedback, and instruction. But rating student work against a construct like this is harder than it looks: * **Construct is rarely a single skill** * Most constructs bundle several indicators (e.g., synthesizing sources, addressing counterarguments, drawing conclusions) that don't always move together * Essay can be strong on one indicator and weak on another – a single holistic score hides that * **Construct isn't the same as writing quality** * Fluent, well-organized writing can be thin on reasoning, while rough writing can also carry real reasoning * Rating must isolate the construct itself, not assess general essay quality * **Even human experts don't always agree** * Reliable rating takes calibration: shared rubrics, normalizing sessions, and consensus across raters * Some indicators remain difficult to rate consistently, even after calibration – that ceiling must be reported, not hidden Asking human experts to rate every student's work against every indicator, across a full class or cohort, does not scale. ## What we're building Our Durable Skills evaluators rate student work against a construct's indicators, using a rubric developed and calibrated with subject-matter experts. | Output | Description | | :--------------------------------------------- | :------------------------------------------------------------------------------------------------------------ | | **Fine-grained, indicator-level ratings** | Replaces a single holistic score with a rating for each named skill the construct bundles together | | **Evidence and rationale for every judgment** | Verbatim quotes and reasoning behind each rating, so a teacher or researcher can check *why*, not just *what* | | **Reported against a human agreement ceiling** | Human inter-rater agreement is measured and reported alongside model results, so claims are scoped honestly | Our evaluators judge whether student work demonstrates a construct at the indicator level: | Evaluator | Description | | :--------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------- | | [**Critical Thinking**](/evaluators/durable-skills-evaluators/critical-thinking)
| Rates a student's source-based argumentative essay for critical thinking across 5 rubric indicators | ## Related topics Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. Rate a student essay for critical thinking, with evidence quotes and rationale for every indicator. # Introduction Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/introduction Learn how feedback evaluators score AI-generated writing feedback across dimensions like actionability, tone, and manageability, with binary outputs. ## The problem Edtech developers often wonder if the AI-generated feedback they're delivering to students is actually good coaching. Feedback can be warm but generic, accurate but overwhelming, clear but off-task. Feedback quality encompasses multiple dimensions, making a single quality score for a piece of feedback misleading. As AI-generated feedback enters classrooms at scale, these dimensions can fail independently and quietly. ## What we're building Our feedback evaluators surface feedback quality as a multidimensional profile, rather than a verdict. Edtech developers can see the qualities that a piece of AI-generated feedback exhibits, which it's missing, and what to adjust. This helps them measure, monitor, and improve the quality of educators' feedback to students at scale. Our feedback evaluators are anchored in the Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗. | Evaluator | Description | | :--------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------- | | [Strength Acknowledgement](/evaluators/feedback-evaluators/strength-acknowledgement)
| Determines whether feedback names something specific and authentic the student did well, distinct from generic or unanchored praise | | [Revision Actionability](/evaluators/feedback-evaluators/revision-actionability)
| Determines whether feedback gives a clear, usable next step the student can act on without additional clarification | | [Student Response Specificity](/evaluators/feedback-evaluators/student-response-specificity)
| Determines whether feedback is clearly based on the student's specific response | | [Revision Accuracy](/evaluators/feedback-evaluators/revision-accuracy)
| Determines whether feedback correctly identifies whether the student needed to revise | | [Revision Manageability](/evaluators/feedback-evaluators/revision-manageability)
| Determines whether the amount of feedback is manageable for the student | | [Withholding Answers](/evaluators/feedback-evaluators/withholding-answers)
| Determines whether feedback guides the student toward a revision without doing the cognitive work for them | | [Tone Appropriateness](/evaluators/feedback-evaluators/tone-appropriateness)
| Determines whether feedback strikes a tone that is appropriate and constructive for the student | ## Scope and limitations Feedback evaluator outputs should not be used for high-stakes applications like grading, assessment, or placement decisions without human review. Remember that LLM scores can vary across runs, especially on borderline cases. We recommend keeping a human in the loop and treating outputs as directional signals vs. definitive judgments. | Limitation | Details | | :----------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------- | | **Validated grade band** | Evaluator validated for grades 8-9 only | | **Validated task type** | Limited to short claim-with-evidence "because" completions from Quill.org – generalization to other prompts, genres, or subject areas is unverified | | **Binary output** | Feedback evaluators reduce a nuanced judgment to a binary 0 or 1 output, plus rationale | ## Related topics Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Revision Accuracy Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/revision-accuracy Check whether feedback correctly signals if a student response needs revision or is complete. Binary appropriateness score with reasoning and features. [Evaluator last updated June 24, 2026.](#evaluator-release-history) ## Overview The Revision Accuracy evaluator assesses whether a piece of feedback correctly identifies whether a student's response has met the task goal and thus does not require further revision. The evaluator considers: * Accurate task assessment (whether the response meets the task's relevant requirements) * Revision-need identification (distinguishing between feedback that should direct revision and feedback that should signal "move on") * Appropriate signal when the task is complete (signaling the student can move on when the goal is met) ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-accuracy/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-accuracy/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-accuracy/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------- | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher feedback to be evaluated | Yes | ```json Example input theme={null} { "student_text": "Some people think AI-powered pets are a good alternative to real pets because they could help around the house etc.", "feedback_text": "You're right, the AI pets could help around the house. Can you find some other details from the article that you could add to make your claim stronger?" } ``` ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when the feedback's stance matches reality — it directs revision when the response doesn't meet the goal, or signals "move on" when the response does. A 0 signals feedback that misses needed revision (telling the student they're done when they aren't) or asks for revision when the response already meets the task goal. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (accurate task assessment, revision-need identification, appropriate signal when the task is complete), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to align the feedback's stance with the task goal, for developers iterating on prompts or for teachers using the decision instructionally | ```json Example output theme={null} { "reasoning": "The relevant task goal is to produce a claim with at least one relevant supporting reason or piece of evidence. The student does make a clear claim: AI-powered pets are a good alternative to real pets. The support given is that they could help around the house, which is a relevant reason, but it is very vague and weakened by \"etc.,\" so it does not function as sufficiently specific support on its own. That means the response still needs revision to meet the claim-and-support goal. The teacher feedback correctly recognizes the basic idea as relevant, but then clearly asks the student to add other details from the article to strengthen the claim. That is a clear revision signal and matches the fact that the student needs to revise rather than move on.", "key_features": { "accurate_task_assessment": { "met": 1, "justification": "The feedback treats the response as needing improvement, which matches the student text because the support is too vague (\"help around the house etc.\") to fully meet the claim-and-evidence goal." }, "revision_need_identification": { "met": 1, "justification": "The teacher clearly signals revision is needed by asking the student to add more details from the article, which is the correct next step for this incomplete response." }, "appropriate_signal_when_task_complete": { "met": 0, "justification": "This feature is not applicable because the student response does not yet meet the relevant task requirements, so a move-on signal would not be appropriate." } }, "proposed_adjustment": "The feedback already meets the criterion. It could be even stronger by naming the problem more directly, for example: \"Your claim is clear, but your reason is too vague right now. Add one or two specific details from the article to explain how AI pets help around the house.\"", "appropriate_feedback_score": 1 } ``` ## Interpreting results | Output | How to use it | | :-------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Revision accuracy score + Reasoning** | Evaluate whether your generated feedback is solving the correct problem. Validate that your prompts respond to actual student need rather than defaulting to a fixed stance (always affirm, or always find something to fix) | | **Key features + Proposed adjustment** | Pinpoint and correct the specific failure mode. Require the model to assess whether the response meets the task goal before deciding to direct revision; target the specific failure direction | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Revision Actionability Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/revision-actionability Score whether writing feedback gives students a clear, usable next step. Binary actionability evaluator with reasoning, run via SDK or playground. [Evaluator last updated June 24, 2026.](#evaluator-release-history) ## Overview The Revision Actionability evaluator assesses whether a piece of feedback gives the student a clear, usable next step they can reasonably act on without additional clarification. The evaluator considers: * Presence of a directive verb (e.g., add, replace, clarify, explain, revise) or focused question that points somewhere specific * Whether feedback goes beyond evaluative comments (e.g., "good job," "this is incomplete") * Clarity of the target (is it clear *what* should be revised?) * Specificity of the next move (a concrete directive rather than a vague instruction) * Whether the student could reasonably act without further clarification or more information * Whether a next step is warranted at all (a response that didn't require revision should not draw a forced directive) ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-actionability/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-actionability/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-actionability/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------- | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher feedback to be evaluated | Yes | ```json Example input theme={null} { "student_text": "Some people think AI-powered pets are a good alternative to real pets because they could help around the house etc.", "feedback_text": "You're right, the AI pets could help around the house. Can you find some other details from the article that you could add to make your claim stronger?" } ``` ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Quality score** | Binary judgment (1 / 0). A 1 applies when feedback names a concrete action the student can take — add, replace, clarify, explain, ask, revise — or appropriately omits a next step when the response required no revision. A 0 signals feedback that is purely evaluative, too vague to act on, or too thin to direct revision. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (directive verb or focused question, clarity of the target, specificity of the next move, whether the student could reasonably act without further clarification), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to strengthen the next step, for developers iterating on prompts or for teachers using the directive instructionally | ```json Example output theme={null} { "reasoning": "The student gives a vague reason ('less of a responsibility') without specific text-based support, so revision is needed. The feedback affirms the idea and adds related context, but names no action the student could take — it does not provide a usable next step.", "key_features": { "directive_verb_or_focused_question": { "met": "no", "justification": "Affirms the student ('That's right') and adds a comment, but contains no directive verb or focused question prompting revision." }, "clarity_of_target": { "met": "no", "justification": "Does not identify any part of the response to revise." }, "specificity_of_next_move": { "met": "no", "justification": "Names no concrete action the student could take." }, "reasonable_student_action": { "met": "no", "justification": "The student is left without a clear sense of what to change or add." } }, "proposed_adjustment": "Add a directive verb or focused question. Example: 'That's a reason from the article. Can you add a specific example of what the article says makes AI pets less of a responsibility?'", "actionable_revision_score": "no" } ``` ## Interpreting results | Output | How to use it | | :---------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Actionable revision score + Reasoning** | Evaluate whether your generated feedback is actually driving revision. Validate that your prompts produce feedback students can act on; aggregate reasoning across runs to detect drift toward describe-only, evaluative feedback | | **Key features + Proposed adjustment** | Pinpoint and correct the specific failure. Require the model to include a directive verb or focused question before closing; surface 0-rated outputs to flag where students may need teacher follow-up | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Revision Manageability Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/revision-manageability Evaluate whether feedback is short and focused enough for students to act on in one revision. Binary manageability score, key features, adjustments. [Evaluator last updated June 24, 2026.](#evaluator-release-history) ## Overview The Revision Manageability evaluator assesses whether a piece of feedback is focused enough that a student can realistically process and use it. Manageable feedback is concise, clear, and prioritizes no more than 2 issues, so that a student reading it knows immediately what to do first. The evaluator considers: * Generally no more than 4 sentences * Generally no more than 2 issues raised, with a clear priority order * Whether it includes small fixes that would have led to a complete success * Whether the student would know immediately what to do first and could act in one revision attempt ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-manageability/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-manageability/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/revision-manageability/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------- | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher feedback to be evaluated | Yes | ```json Example input theme={null} { "student_text": "Some people think AI-powered pets are a good alternative to real pets because they could help around the house etc.", "feedback_text": "You're right, the AI pets could help around the house. Can you find some other details from the article that you could add to make your claim stronger?" } ``` ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when feedback is focused enough that a student could realistically process and act on it in a single revision attempt — generally four sentences or fewer, addressing no more than two clearly prioritized issues — or when the response required no revision and the feedback stays appropriately brief. A 0 signals feedback that is too dense, too long, or raises too many issues at once, or feedback so thin it omits a small fix that would have completed the response. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (length, number of distinct issues, clear priority, whether the student knows the next step), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to bring the feedback into a manageable range, for developers iterating on prompts or for teachers using the feedback instructionally | ```json Example output theme={null} { "reasoning": "The student response gives a very minimal claim: AI-powered pets are a good alternative because they could help around the house, but it ends with \"etc.\" and does not include enough supporting evidence. The teacher feedback responds to that main gap by affirming the existing idea and asking for additional details from the article to strengthen the claim. For manageability, the feedback is short and focused on one main revision move: add more supporting details. It does not introduce multiple separate problems or a long list of changes. The priority is fairly clear because the only issue raised is strengthening the claim with evidence from the article. A student would likely know the next step is to go back to the article and add another supporting detail or details. Therefore, this feedback is manageable in amount and scope.", "key_features": { "length": { "met": 1, "justification": "The feedback is only two sentences, so it is comfortably within the usual manageable length guideline." }, "number_of_distinct_issues": { "met": 1, "justification": "The feedback raises one distinct issue: the student needs to add more details from the article to support the claim." }, "clear_priority": { "met": 1, "justification": "Because only one issue is raised, the priority is clear: strengthen the claim by adding textual details." }, "student_knows_next_step": { "met": 1, "justification": "The student is directly asked to find other details from the article to make the claim stronger, so the immediate next step is apparent." } }, "proposed_adjustment": "No adjustment needed; the feedback already appears manageable.", "manageable_score": 1 } ``` ## Interpreting results | Output | How to use it | | :------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Revision manageability score + Reasoning** | Evaluate whether your generated feedback sets students up to revise. Validate that your prompts produce focused feedback; aggregate reasoning across runs to detect drift toward longer, more exhaustive feedback | | **Key features + Proposed adjustment** | Pinpoint and correct the specific failure mode. Require the model to prioritize the one or two highest-impact issues and cap the total it raises; target the specific failure direction | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Strength Acknowledgement Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/strength-acknowledgement Detect whether feedback names something specific a student did well versus generic praise. Binary strength acknowledgement score with reasoning output. [Evaluator last updated June 24, 2026.](#evaluator-release-history) ## Overview The Strength Acknowledgement evaluator assesses whether a piece of feedback names something specific and authentic that the student did well. The evaluator considers whether: * Praise is authentic or reflexive * Feedback is specific or generic * Feedback is anchored to evidence – i.e., a feature of the student's response * Feedback uses process-vs.-trait framing – i.e., praising what the student did rather than a fixed ability * Acknowledgment is warranted – e.g., "IDK" should not draw false praise ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/strength-acknowledgment/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/strength-acknowledgment/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/strength-acknowledgment/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------- | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher feedback to be evaluated | Yes | ## Output | Field | Description | | :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when feedback names a specific, accurate strength tied to what the student wrote — or appropriately refrains from praise when the response warrants none. A 0 signals generic, unanchored, or inaccurate praise. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (presence of praise, specificity, anchoring to evidence, process-vs.-trait framing), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to strengthen the feedback's acknowledgment, for developers iterating on prompts | ```json Example output theme={null} { "reasoning": "The student response includes a concrete, relevant idea: AI-powered pets could help around the house. Although the phrase etc. is vague, the helping-around-the-house idea is a promising reason that could be developed with evidence. The teacher feedback explicitly acknowledges that specific idea by saying, You're right, the AI pets could help around the house. This is a direct, response-specific acknowledgment of a strength or valid point in the student's writing. The follow-up question then invites the student to strengthen the claim by adding more details from the article, which builds on that identified strength rather than ignoring it. Because the acknowledgment is specific, grounded in the student's actual wording, and framed as a next step for developing the idea, the feedback meets the criterion.", "key_features": { "presence_of_praise": { "met": 1, "justification": "The feedback explicitly affirms a specific student idea with \"You're right, the AI pets could help around the house.\" This is authentic acknowledgment rather than generic praise." }, "specificity": { "met": 1, "justification": "The acknowledgment names the particular idea from the student response: that AI pets could help around the house. It is not vague or interchangeable with feedback on any essay." }, "anchoring_to_evidence": { "met": 1, "justification": "The feedback is clearly tied to wording that appears in the student text, specifically the claim about helping around the house. It is grounded in the student's actual response." }, "process_vs_trait_framing": { "met": 1, "justification": "The feedback focuses on the student's claim and a revision move—adding details from the article to strengthen it—rather than praising a fixed trait. This frames the strength as something to build on through writing process." } }, "proposed_adjustment": "No adjustment needed; the feedback already meets the criterion. If desired, the teacher could make it even stronger by naming one especially useful detail from the article as a model for expansion.", "acknowledges_strength_score": 1 } ``` ## Interpreting results | Output | How to use it | | :------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Acknowledges strength score + Reasoning** | Validate that your AI-generated feedback is building student awareness, not just adding polite filler. Ensure that it includes specific, earned praise. Aggregate reasoning across runs to detect drift toward generic and/or polite openers. | | **Key features + Proposed adjustment** | Pinpoint and correct the specific failure mode. Adjust prompts to require the model to name a specific feature of the student's work before any directive; target the missing feature directly | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Student Response Specificity Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/student-response-specificity Verify that feedback references the student's actual response instead of template phrases. Binary student response anchor score with reasoning output. [Evaluator last updated June 24, 2026.](#evaluator-release-history) ## Overview The Student Response Specificity evaluator assesses whether a piece of feedback is clearly based on the student's specific response — i.e., referencing, building on, or responding to the student's own idea, wording, or use of evidence. In short, it assesses whether the feedback demonstrates an accurate understanding of what the student wrote. The evaluator considers whether: * There is a specific reference to the student's work (the feedback names or builds on the student's particular idea, wording, or evidence) * Feedback is generic or template-based (a stock phrase that could apply to any response) * Feedback is based on an accurate understanding and interpretation of the student's response * Feedback addresses something the student did not actually say or attempt ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/student-response-specificity/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/student-response-specificity/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/student-response-specificity/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------- | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher feedback to be evaluated | Yes | ```json Example input theme={null} { "student_text": "Some people think AI-powered pets are a good alternative to real pets because they could help around the house etc.", "feedback_text": "You're right, the AI pets could help around the house. Can you find some other details from the article that you could add to make your claim stronger?" } ``` ## Output | Field | Description | | :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when feedback references, builds on, or responds to the student's own idea, wording, or use of evidence and demonstrates accurate understanding of what they wrote. A 0 signals feedback that is generic or template-like, built on a misinterpretation, or addressed to something the student did not say or attempt. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (specific reference to the student's work, not generic or template-based, engagement based on accurate understanding), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to anchor the feedback more clearly in the student's response, for developers iterating on prompts or for teachers using the feedback instructionally | ```json Example output theme={null} { "reasoning": "The student's specific claim is that AI-powered pets are a good alternative because \"they could help around the house.\" The teacher feedback directly echoes that exact idea by saying \"the AI pets could help around the house,\" which shows a clear connection to the student's actual wording and reasoning. The follow-up suggestion to add other details from the article is tied to that existing claim rather than being completely generic. The feedback also accurately understands the student's point and does not misread or shift it to a different argument. Therefore, the feedback is sufficiently anchored in the student response.", "key_features": { "specific_reference_to_student_work": { "met": 1, "justification": "The feedback explicitly repeats the student's reason that AI pets \"could help around the house,\" directly referencing the student's actual claim." }, "not_generic_or_template_based": { "met": 1, "justification": "Although it includes a common suggestion to add details, it is not purely generic because it first identifies the student's specific idea about helping around the house." }, "engage_based_on_accurate_understanding": { "met": 1, "justification": "The feedback accurately understands and responds to the student's stated reason rather than introducing a different idea." } }, "proposed_adjustment": "No adjustment needed; the feedback already meets the criterion. It could be even stronger by asking for a specific example of how the pets help around the house.", "anchored_in_student_response_score": 1 } ``` ## Interpreting results | Output | How to use it | | :------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Anchored in student response score + Reasoning** | Evaluate whether your generated feedback is responding to this student's actual work or to a generic version of the task. Validate that your prompts produce responsive feedback; aggregate reasoning across runs to detect drift toward safe, generic phrasing | | **Key features + Proposed adjustment** | Pinpoint and correct the specific failure mode. Require the model to quote or restate a specific element of the student's response before offering guidance; target the specific failure mode | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Tone Appropriateness Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/tone-appropriateness Assess whether feedback tone is supportive and constructive, targeting the work rather than the student. Binary tone appropriateness score and features. [Evaluator last updated July 29, 2026.](#evaluator-release-history) ## Overview The Tone Appropriateness evaluator assesses whether a piece of teacher feedback strikes a tone that is appropriate and constructive for the student — supportive even when pointing out areas for improvement, addressing the work rather than the student, and avoiding praise so inflated that it misrepresents the quality of the work. The evaluator considers whether the feedback: * Uses language that is neutral and professional, versus harsh or dismissive * Targets the work versus judging the student as a person * Matches the actual quality of the work, versus overstating it, when giving praise Tone judgments are culturally and contextually sensitive. What reads as "supportive" or "harsh" may vary across communities, and labels reflect the judgment of a small set of human annotators applying a rubric adapted for machine use. ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | On this dimension's held-out test split, Claude Haiku 4.5 scored highest. We chose to ship GPT-5.4 here for consistency across the evaluator suite, rather than for its margin on this individual dimension. ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/tone-appropriateness/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/tone-appropriateness/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/tone-appropriateness/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------------------------ | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher- or AI-generated feedback to be evaluated | Yes | ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when the feedback uses neutral, professional, supportive language that targets the work and keeps any praise proportionate to the work's quality. A 0 signals feedback that is harsh, dismissive, or shaming, that judges the student rather than the work, or that uses exaggerated / inflated praise. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (neutral professional language, targets work not student, praise proportionate to work), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to bring the feedback's tone into an appropriate, constructive range, for developers iterating on prompts | ```json Example output theme={null} theme={null} { "reasoning": "The response is incomplete — it gives only a vague reason ('cost') without the specific, text-based evidence the task calls for — so describing it as 'absolutely perfect' and 'one of the best answers I've seen' is inflated and exaggerated relative to the work. It gives the student no accurate signal about where they stand.", "key_features": { "neutral_professional_language": { "met": 0, "justification": "Uses exaggerated, effusive language ('absolutely perfect,' 'amazing!!') rather than a neutral, professional tone." }, "targets_work_not_student": { "met": 1, "justification": "Addresses the response rather than attacking or judging the student as a person." }, "praise_proportionate_to_work": { "met": 0, "justification": "Praise is disproportionate — it calls an incomplete response 'perfect' and 'one of the best answers I've seen.'" } }, "proposed_adjustment": "Keep praise proportionate to the work and tie it to a specific, accurate strength. Example: 'You gave a clear, text-based reason with cost — nice start. To strengthen it, add one specific cost the article mentions.'", "tone_appropriateness_score": 0 } ``` ## Interpreting results | Output | How to use it | | :----------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Tone appropriateness score + Reasoning** | Validate that your AI-generated feedback supports students emotionally without overstating, shaming, or evaluating the student rather than the work. Aggregate reasoning across runs to detect tone drift — models tuned for friendliness tend to drift toward effusive, exaggerated praise that reads pleasantly but misrepresents quality, a failure mode that won't trigger complaints on its own. | | **Key features + Proposed adjustment** | Pinpoint whether a "0" is driven by harsh/dismissive language, judging the student rather than the work, or inflated praise. Adjust prompts to require the model to describe the work rather than judge the student, and to keep any praise proportionate to the response. | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | July 29, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Withholding Answers Source: https://docs.learningcommons.org/evaluators/feedback-evaluators/withholding-answers Check that feedback guides revision with hints and questions instead of giving away the answer. Binary withholding answers score for coaching feedback. [Evaluator last updated July 29, 2026.](#evaluator-release-history) ## Overview The Withholding Answers evaluator assesses whether a piece of teacher feedback guides the student toward a revision without doing the cognitive work for them: * Scaffolds through hints, guiding questions, or naming the kind of content or evidence that is missing * Doesn't just supply the evidence, rewrite the response, or otherwise provide a complete or near-complete answer The evaluator considers whether the feedback: * Points toward where to find evidence vs. supplying the actual evidence * Prompts the student to revise rather than rewriting or modeling the full response * Leaves core thinking (selecting, explaining, or wording the evidence) to the student ## At a glance | | | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Teacher feedback on a student writing response | | **Supported grades** | 8–9 | | **Rubric** | Productive Coaching rubric developed by [Quill.org](https://www.quill.org/) ↗ and [Leanlab Education](https://www.leanlabeducation.org/) ↗, in partnership with [Anastasiya A. Lipnevich](https://www.anastasiyalipnevich.com/) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :------------------------------------------------------------------------------- | | **Model used** | GPT-5.4 (`gpt-5.4-2026-03-05`) | | **Temperature** | 1 | | **Optimization** | DSPy + GEPA (Genetic-Pareto) prompt optimization against expert-annotated labels | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/withholding-answers/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/withholding-answers/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/feedback/ela-writing/withholding-answers/user.txt) ↗) | ## Inputs | Input | Description | Required | | :---------------- | :------------------------------------------------ | :------- | | **Student text** | Student's written response | Yes | | **Feedback text** | Teacher- or AI-generated feedback to be evaluated | Yes | ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Quality score** | Binary judgment (1 / 0). A 1 applies when the feedback guides revision through hints, guiding questions, or by naming what kind of content or evidence is missing — without supplying it — or when the student's response didn't require revision and there was no answer to give away. A 0 signals feedback that does the work for the student: supplying the specific evidence, rewriting the response, or otherwise providing a complete or near-complete answer. | | **Reasoning** | High-level summary of why the feedback received this judgment | | **Key features** | One entry per factor driving the judgment (points toward evidence without supplying, prompts revision without rewriting, leaves core thinking to student), each marked met (1) / not met (0) with a justification | | **Proposed adjustment** | Suggested moves to convert answer-giving into scaffolding, for developers iterating on prompts | ```json Example output theme={null} theme={null} { "reasoning": "The feedback asks the student to explain and provide examples of why an AI pet costs less, but does not supply those examples or specific costs itself. The cognitive work — locating and articulating the evidence — is left to the student.", "key_features": { "points_toward_evidence_without_supplying": { "met": 1, "justification": "Asks the student to explain and give examples of why cost is lower, without naming the specific costs or quoting the text." }, "prompts_revision_without_rewriting": { "met": 1, "justification": "Prompts the student to revise; it does not rewrite or model the response for them." }, "leaves_core_thinking_to_student": { "met": 1, "justification": "Selecting, explaining, and wording the evidence is left to the student." } }, "proposed_adjustment": "None needed for withholding-answers. The feedback scaffolds without completing the task.", "withholding_answers_score": 1 } ``` ## Interpreting results | Output | How to use it | | :---------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Withholding answers score + Reasoning** | Validate that your AI-generated feedback is coaching students through the work rather than doing it for them. Aggregate reasoning across runs to detect answer-giving drift — models tuned to be maximally helpful tend to drift toward supplying evidence or modeling full revisions as they're tuned for helpfulness. | | **Key features + Proposed adjustment** | Pinpoint exactly where a comment crosses from guiding into answer-giving. Adjust prompts to require the model to point toward what's missing (the kind of evidence, or where to look) rather than supply it, and to withhold any full or near-full revision. | ## Evaluator release history | Date | Changed | | ------------- | ------------- | | July 29, 2026 | First release | ## Related topics Explore other evaluators that assess the quality of coaching feedback. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Quickstart Source: https://docs.learningcommons.org/evaluators/getting-started/quickstart Run your first Literacy evaluator on text using the Evaluators playground, TypeScript or Python SDK, or a Python notebook, then review results. ## What you'll do Run our [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) on some text to evaluate it for a given grade level. | Method | When to use | | :---------------------------------------------- | :-------------------------------------------------- | | [Evaluators playground](#evaluators-playground) | For a quick demo of how evaluators work | | [SDK](#sdk) | To integrate into your TypeScript or Python project | | [Python notebook](#python-notebooks) | For quick prototyping | ## What you'll need * Text you want to evaluate * Grade level of the intended audience * API keys required by the evaluators you want to use Not required for [Evaluators playground](#evaluators-playground) ### Required API keys By default, each evaluator uses a provider and model that we have tested for reliability for that task. As a result, different evaluators require different API keys. | Evaluator | Required API key(s) | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | | [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction)
(except for [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) and [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure)) | [Google](https://aistudio.google.com/) | |      [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity)  | [Google](https://aistudio.google.com/) and [OpenAI](https://platform.openai.com/) | |      [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure)  | [OpenAI](https://platform.openai.com/) | | [Feedback evaluators](/evaluators/feedback-evaluators) | [OpenAI](https://platform.openai.com/) | | [Academic Standards evaluators](/evaluators/academic-standards-evaluators/introduction) | [Anthropic](https://claude.ai/) | You can override our evaluators' defaults with any [Google](https://aistudio.google.com/), [OpenAI](https://platform.openai.com/), or [Anthropic](https://claude.ai/) model. When overriding with an Anthropic model, an Anthropic API key is required. ## Steps The [Evaluators playground](https://platform.learningcommons.org/apps/evaluators/playground) ↗ is the easiest way to see our evaluators in action. Choose the evaluators you want to run on your input (e.g. [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) or [feedback evaluators](/evaluators/feedback-evaluators/introduction)). **Student-Facing Text evaluators**: Choose the grade level of your intended audience, and copy and paste the content you want to evaluate. **Feedback evaluators**: Copy and paste the student text and the feedback text you want to evaluate. Click **Evaluate** to run our [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) or [Feedback evaluators](/evaluators/feedback-evaluators/introduction) on your input. Expand each evaluator's results to see its score and reasoning. The Evaluators playground is primarily a demo. Check out the [SDK](#sdk) or [Python notebooks](#python-notebooks) when implementing evaluators into your automated processes. Run evaluators from your project by installing the SDK of your choice. | Language | Installation | Latest version | | ---------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | | TypeScript | [GitHub](https://github.com/learning-commons-org/evaluators/tree/main/sdks/typescript#installation) ↗ | [ npm version](https://www.npmjs.com/package/@learning-commons/evaluators) | | Python | [GitHub](https://github.com/learning-commons-org/evaluators/tree/main/sdks/python#installation) ↗ | [ PyPI version](https://pypi.org) | Install the SDK from the package registry rather than cloning the [evaluators repository](https://github.com/learning-commons-org/evaluators) ↗. The published packages are versioned, so you can pick up fixes and new evaluators with a standard package update: ```bash Update to the latest version theme={null} theme={null} theme={null} # TypeScript npm install @learning-commons/evaluators@latest # Python pip install --upgrade learning-commons-evaluators ``` [Contact us](mailto:support@learningcommons.org) ↗ to request additional SDK language support. You can also [sign up on the Learning Commons Platform](http://platform.learningcommons.org/) ↗ for updates on availability. Import evaluators to start evaluating text in your project: ```typescript TypeScript theme={null} theme={null} theme={null} import { GradeLevelAppropriatenessEvaluator } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: process.env.GOOGLE_API_KEY, }); const text = "The cat's out of the bag now."; const result = await evaluator.evaluate(text); console.log(result.score); // 4-5 ``` ```python Python theme={null} theme={null} theme={null} import logging from learning_commons_evaluators import ( GradeLevelAppropriateness, GradeLevelAppropriatenessEvaluationInput, GoogleLLMProviderConfig, create_config_no_telemetry, ) # Logger logging.basicConfig(level=logging.INFO) # Config with Google API key config = create_config_no_telemetry( google_llm_provider_config=GoogleLLMProviderConfig(api_key="your-google-key"), ) # Instantiate GradeLevelAppropriatenessEvaluator with created config evaluator = GradeLevelAppropriatenessEvaluator(config) # Evaluate some text for grade level appropriateness result = evaluator.evaluate_sync( GradeLevelAppropriatenessEvaluationInput(text="The cat's out of the bag now.") ) print(result.answer.label) # e.g. "Moderately complex" print(result.explanation.summary) # Reasoning for the score ``` See the [SDK API reference](/evaluators/sdk-api-reference/overview) for more implementation details. The Python interpreter powers our evaluators. All [downloadable examples](https://github.com/learning-commons-org/evaluators/tree/main/evals) ↗ and tutorials are provided as Python snippets. Install Python 3.10 or newer. To verify your version of Python: ```shell theme={null} python3 --version ``` Creating an isolated environment prevents conflicts between Python packages used in this project and others on your system: ```shell theme={null} python3 -m venv .venv source .venv/bin/activate # Activates environment ``` Remember to activate the virtual environment for each new shell session. Install all required packages listed in [`requirements.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/requirements.txt) ↗: ```shell theme={null} pip install -r evals/requirements.txt ``` Set your API keys as environment variables in your shell session: ```shell theme={null} export OPENAI_API_KEY="sk-your-key-here" export GOOGLE_API_KEY="your-key-here" ``` Start a Jupyter Notebook in your web browser (usually at `http://localhost:8888`): ```shell theme={null} theme={null} theme={null} jupyter lab ``` Create a new notebook by clicking the **Notebook: Python 3 (ipykernel)** tile in the Jupyter Lab launcher. Alternatively, select **File > New > Notebook > Python 3 (ipykernel)** in the menu. Run an evaluator by copying the code from our [ examples](https://github.com/learning-commons-org/evaluators/tree/main/evals) ↗ into the cells of your notebook. You can also use an IDE with Python and Jupyter Notebook support (e.g. VS Code with Microsoft's [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) and [Jupyter](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) extensions). Install Python 3.10 or newer. To verify your version of Python: ```shell theme={null} python3 --version ``` In Command Prompt: ```shell theme={null} python -m venv .venv .venv\Scripts\activate ``` Or in PowerShell: ```shell theme={null} python -m venv .venv .venv\Scripts\Activate.ps1 ``` Remember to activate the virtual environment for each new shell session. Install all required packages listed in [`requirements.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/requirements.txt) ↗: ```shell theme={null} pip install -r evals/requirements.txt ``` Set your API keys as environment variables in Command Prompt: ```shell theme={null} export OPENAI_API_KEY="sk-your-key-here" export GOOGLE_API_KEY="your-key-here" ``` Or in PowerShell: ```shell theme={null} $env:OPENAI_API_KEY="sk-your-key-here" $env:GOOGLE_API_KEY="your-key-here" ``` Start a Jupyter Notebook in your web browser (usually at `http://localhost:8888`): ```shell theme={null} theme={null} theme={null} jupyter lab ``` Create a new notebook by clicking the **Notebook: Python 3 (ipykernel)** tile in the Jupyter Lab launcher. Alternatively, select **File > New > Notebook > Python 3 (ipykernel)** in the menu. Run an evaluator by copying the code from our [ examples](https://github.com/learning-commons-org/evaluators/tree/main/evals) ↗ into the cells of your notebook. You can also use an IDE with Python and Jupyter Notebook support (e.g. VS Code with Microsoft's [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python) and [Jupyter](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.jupyter) extensions). ## Related topics Learn how dimensions, rubrics, and accuracy shape evaluator results. Configure evaluators, interpret outputs, and handle errors in your project. # Licenses Source: https://docs.learningcommons.org/evaluators/resources/licenses Learn about the licensing for evaluator code, which is licensed under MIT, and other licensing information for evaluator resources. The **Evaluators** code is licensed under [MIT](https://opensource.org/license/mit) ↗. **Evaluators** content (including the prompt and settings information) is provided by Learning Commons under the CC BY 4.0 International license ([CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.en) ↗). Annotated CLEAR Corpus is provided by Learning Commons (including annotations and enhancements) under CC BY-NC-SA 4.0 ([CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en) ↗). The original dataset from CLEAR Corpus can be found at [The CLEAR Corpus by CommonLit](https://www.commonlit.org/blog/introducing-the-clear-corpus-an-open-dataset-to-advance-research-28ff8cfea84a/) ↗ licensed under CC BY-NC-SA 4.0. **How to Cite the Evaluator Code:** Learning Commons (2025). Evaluators. GitHub. [https://github.com/learning-commons-org/evaluators](https://github.com/learning-commons-org/evaluators) ↗. Licensed under MIT. **How to Cite the Evaluator:** Learning Commons. (2025). Evaluators content (including the prompt and settings information) is available at GitHub. [https://github.com/learning-commons-org/evaluators](https://github.com/learning-commons-org/evaluators) ↗. Licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.en) ↗. # Release notes Source: https://docs.learningcommons.org/evaluators/resources/release-notes Release notes for Student-Facing Text, Feedback, Academic Standards, and Durable Skills evaluators, plus TypeScript and Python SDK version updates. ## Introducing Durable Skills evaluators Released [Durable Skills evaluators](/evaluators/durable-skills-evaluators/introduction) to rate student work against a construct's indicators, with evidence and reasoning for every judgment: | | | | :--------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------- | | [Critical Thinking](/evaluators/durable-skills-evaluators/critical-thinking) | Rates a student's source-based argumentative essay for critical thinking across 5 rubric indicators | ## Added Student-Facing Text evaluator | | | | :---------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------- | | [Organizational Structure](/evaluators/student-facing-text-evaluators/organizational-structure) | Assesses how demanding a text's organizational structure is for students at a given grade level | ## Added Feedback evaluators | | | | :--------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | | [Tone Appropriateness](/evaluators/feedback-evaluators/tone-appropriateness) | Assesses whether teacher feedback strikes a tone that is appropriate and constructive for the student | | [Withholding Answers](/evaluators/feedback-evaluators/withholding-answers) | Assesses whether teacher feedback guides the student toward a revision without doing the cognitive work for them | ## Introducing Academic Standards evaluators Released [Academic Standards evaluators](/evaluators/academic-standards-evaluators/introduction) to measure how aligned educational content is to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards): | | | | :--------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Math Standards Alignment](/evaluators/academic-standards-evaluators/math-standards-alignment) | Checks a math question against an academic standard’s corresponding [learning components](/knowledge-graph/datasets/learning-components/math-learning-components) | ## Introducing Feedback evaluators Released [Feedback evaluators](/evaluators/feedback-evaluators/introduction) to assess the quality of AI-generated or teacher feedback: | | | | :------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- | | [Strength Acknowledgement](/evaluators/feedback-evaluators/strength-acknowledgement) | Assesses whether feedback names something specific and authentic the student did well, distinct from generic or unanchored praise | | [Revision Actionability](/evaluators/feedback-evaluators/revision-actionability) | Assesses whether feedback gives a clear, usable next step the student can act on without additional clarification | | [Student Response Specificity](/evaluators/feedback-evaluators/student-response-specificity) | Assesses whether feedback is clearly based on the student's specific response | | [Revision Accuracy](/evaluators/feedback-evaluators/revision-accuracy) | Assesses whether feedback correctly identifies whether the student needed to revise | | [Revision Manageability](/evaluators/feedback-evaluators/revision-manageability) | Assesses whether the amount of feedback is manageable for the student | ## Added Student-Facing Text evaluator | | | | :---------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------- | | [Reference Knowledge Demands](/evaluators/student-facing-text-evaluators/reference-knowledge-demands) | Assesses what a text assumes you've already encountered and then builds on to create meaning | ## Introducing the Python SDK Released a [Python SDK](https://github.com/learning-commons-org/evaluators/tree/main/sdks/python) ↗ with support for the following [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction): * [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) * [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness) ## Expanded TypeScript SDK support Added [`--bypass-row-limit`](/evaluators/sdk-api-reference/typescript/batch-evaluator#options) option for the [batch evaluator](/evaluators/sdk-api-reference/typescript/batch-evaluator). ## Added Student-Facing Text evaluator | | | | :---------------------------------------------------------------------------- | :----------------------------------------------------------- | | [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity) | Analyzes how clearly a text communicates its central purpose | ## Expanded TypeScript SDK support * [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity) ## Added Student-Facing Text evaluator | | | | :---------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------- | | [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness) | Analyzes whether language is literal and explicit or relies on figurative, abstract, or implied meaning that requires interpretation | ## Expanded TypeScript SDK support * [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands) * [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness) ## Introducing the TypeScript SDK Released a [TypeScript SDK](https://github.com/learning-commons-org/evaluators/tree/main/sdks/typescript) ↗ with support for the following [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction): * [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) * [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) * [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) ## Introducing the Evaluators playground Released the [Evaluators playground](https://platform.learningcommons.org/apps/evaluators/playground) ↗, an interactive environment for testing evaluators without setup or integration ## Added Student-Facing Text evaluator | | | | :------------------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------ | | [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands) | Identifies key concepts in a text and evaluates background knowledge demands by grade level | ## Expanded Vocabulary Complexity support Expanded support for [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) to include grades 5–12 ## Expanded Sentence Structure support Expanded support for [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) to include grades 5–12 ## Introducing Student-Facing Text evaluators Released [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction): | | | | :---------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------- | | [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) | Determines whether AI-generated text is suitable for a grade band and suggests scaffolding that can support instruction of the text | | [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) | Measures how challenging vocabulary in informational texts may be for students in grades 3–4 | | [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) | Assesses the complexity of sentence structure in informational texts for grades 3–4 | ## Related topics Report issues or ask questions about a recent release. # Support Source: https://docs.learningcommons.org/evaluators/resources/support Get help with evaluators by opening an issue on GitHub or contacting support. Learn about the private beta program for additional evaluators. We want to hear from you. For questions or feedback, please [open an issue](https://github.com/learning-commons-org/evaluators/issues) ↗ or reach out to us at [support@learningcommons.org](mailto:support@learningcommons.org) ↗. # Terms of use Source: https://docs.learningcommons.org/evaluators/resources/terms-of-use Review the terms of use for evaluators, including usage rights, restrictions, and legal information for using our evaluation tools. These terms are part of [our Terms of Use ↗](https://learningcommons.org/terms-of-use/) and govern your use of our tools, datasets, documentation, and other public resources. Capitalized terms not defined here have the same meanings set out in the Terms of Use. By using any resources in this repository — including datasets, documentation, our tools Knowledge Graph, Evaluators, Agent Skills, or other downloadable assets — you agree to the following: ### 1. Intended Use * These resources are provided for exploratory, research, and other uses permitted under their respective licenses. * They are not intended for high-stakes educational decisions such as formal student evaluation, instructional placement, or grading. ### 2. Licensing & Compliance * Each resource is released under its specified license. * You must review and comply with all terms and conditions in that license, including any attribution or usage limitations described in the accompanying documentation. * Some resources (e.g., individual Evaluators, Agent Skills, datasets, or Knowledge Graph components) may have additional license or usage terms. Review the repository’s README, LICENSE, and related documentation before use. ### 3. Updates & Versioning * Resources may be updated over time to improve accuracy, add features, or correct issues. * Users should check the release information or tags to ensure they are using the latest available version. ### 4. Responsible Use * Use of these resources must comply with all applicable laws and align with our [Community Guidelines ↗](https://learningcommons.org/community-guidelines/). * You must not: * Use the data to promote discrimination, misinformation, or harm * Circumvent safeguards or ignore usage restrictions ### 5. Limitations & Accuracy * Claims of accuracy, safety, fairness, or pedagogical effectiveness should not be made solely on the basis of outputs from these tools. * Human judgment is expected when interpreting results. * Performance may vary depending on factors such as input type, grade level, data format, or technical implementation. See the documentation for any known limitations. # Overview Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/overview Overview of the Evaluators SDK for TypeScript and Python, covering installation, quickstart, configuration, batch evaluation, and release history. Our SDKs let you use evaluators in your own project. You can: * Configure evaluators * Understand their outputs * Evaluate text in batches  TypeScript only * Handle errors * Customize logging * Send telemetry data ## Installation Install the SDK of your choice: | Language | Installation | Latest version | | ---------- | ----------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | | TypeScript | [GitHub](https://github.com/learning-commons-org/evaluators/tree/main/sdks/typescript#installation) ↗ | [npm version](https://www.npmjs.com/package/@learning-commons/evaluators) | | Python | [GitHub](https://github.com/learning-commons-org/evaluators/tree/main/sdks/python#installation) ↗ | [PyPI version](https://pypi.org) | Install the SDK from the package registry rather than cloning the [evaluators repository](https://github.com/learning-commons-org/evaluators) ↗. The published packages are versioned, so you can pick up fixes and new evaluators with a standard package update: ```bash Update to the latest version theme={null} theme={null} theme={null} # TypeScript npm install @learning-commons/evaluators@latest # Python pip install --upgrade learning-commons-evaluators ``` [Contact us](mailto:support@learningcommons.org) ↗ to request additional SDK language support. You can also [sign up on the Learning Commons Platform](http://platform.learningcommons.org/) ↗ for updates on availability. ## Quickstart ```typescript TypeScript theme={null} theme={null} theme={null} import { GradeLevelAppropriatenessEvaluator } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: process.env.GOOGLE_API_KEY, }); const text = "The cat's out of the bag now."; const result = await evaluator.evaluate(text); console.log(result.score); // 4-5 ``` ```python Python theme={null} theme={null} theme={null} import logging from learning_commons_evaluators import ( GradeLevelAppropriateness, GradeLevelAppropriatenessEvaluationInput, GoogleLLMProviderConfig, create_config_no_telemetry, ) # Logger logging.basicConfig(level=logging.INFO) # Config with Google API key config = create_config_no_telemetry( google_llm_provider_config=GoogleLLMProviderConfig(api_key="your-google-key"), ) # Instantiate GradeLevelAppropriatenessEvaluator with created config evaluator = GradeLevelAppropriatenessEvaluator(config) # Evaluate some text for grade level appropriateness result = evaluator.evaluate_sync( GradeLevelAppropriatenessEvaluationInput(text="The cat's out of the bag now.") ) print(result.answer.label) # e.g. "Moderately complex" print(result.explanation.summary) # Reasoning for the score ``` ## SDK release history ### TypeScript [Read the full changelog here](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/CHANGELOG.md). | Date | Changed | Version | | -------------- | ------------------------------------------------------------------------------------------- | ------- | | Jun 11, 2026 | Added `--help`, `--version`, and other options to the batch evaluator | v0.7.0 | | May 22, 2026 | Added `--bypass-row-limit` option for the batch evaluator | v0.6.0 | | May 07, 2026 | Added support for Purpose Clarity evaluator. Added `modelOverride` option to all evaluators | v0.5.0 | | March 23, 2026 | Added Batch CSV evaluator | v0.4.0 | | March 20, 2026 | Added support for Meaning Directness evaluator | v0.3.0 | | March 18, 2026 | Added support for Background Knowledge Demands evaluator | v0.2.0 | | March 13, 2026 | First release | v0.1.0 | ### Python [Read the full changelog here](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/CHANGELOG.md). | Date | Changed | Version | | ------------ | ----------------------------------------------------------- | ------- | | Jun 11, 2026 | Added support for the Grade Level Appropriateness Evaluator | v0.2.0 | | May 22, 2026 | First release | v0.1.0 | ## Related topics Install the SDK and run your first evaluator. Configure Python evaluators, including API keys and options. Configure TypeScript evaluators, including API keys and options. # Batch evaluator Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/past-versions/typescript-v0.6.0/batch-evaluator Legacy docs for the TypeScript SDK v0.6.0 batch evaluator, which scores a CSV of text with all literacy evaluators and outputs CSV and HTML results.
v0.4.0
## What you'll do Evaluate a batch of text from a CSV file using all [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction). Results are output in both CSV and HTML format. ## What you'll need * Install the SDK globally ```bash theme={null} npm install -g @learning-commons/evaluators ``` * Create a CSV file with the text you want to evaluate * Must be 50 or fewer input rows (unless using the [`--bypass-row-limit` option](#options)) * Must have `text` and `grade` columns * May include additional columns (will be preserved as-is in the output) ```csv example.csv theme={null} text,grade "The cat sat on the mat.",3 "Photosynthesis is the process by which plants convert sunlight into energy.",5 "The mitochondria are the powerhouse of the cell.",8 ``` ## Running the batch evaluator Run the batch evaluator using `npx` from any directory: ```bash theme={null} npx evaluators-batch ``` You will be prompted for the following information: * CSV file path * Google and OpenAI API keys * Copy and paste directly in terminal window * Alternatively, provide as environment variables (`GOOGLE_API_KEY` and `OPENAI_API_KEY`, by default) * Output directory * Defaults to a folder in the current directory with a human-readable timestamp (e.g. `batch-results-2024-02-07_14-30-22/`) ### Options Pass in options to override the batch evaluator's defaults: ```bash theme={null} evaluators-batch --concurrency 5 --max-retries 3 --no-telemetry ``` | Option | Default | Description | | ----------------------------------------------------- | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | `--concurrency ` | `3` | Number of evaluations to run in parallel. If you have higher rate limits with your provider and model, you can raise this value for faster execution | | `--max-retries ` | `2` | Number of times to retry a failed evaluation | | `--no-telemetry` | Telemetry is enabled | Disable telemetry data collection | | `--bypass-row-limit`
v0.6.0
| `true` | Evaluates a CSV file with more than 50 rows | ### Results You'll see a real-time display of the batch evaluator's progress: ``` Processing evaluations... ████████████░░░░░░░░ 60% (30/50) ✓ grade-level-appropriateness: 6/10 successful ✓ background-knowledge-demands: 6/10 successful ✓ vocabulary: 6/10 successful ✓ sentence-structure: 6/10 successful ⏳ conventionality: 6/10 successful ⏱ Elapsed: 2m 15s | Estimated remaining: 1m 30s ``` The batch evaluator will generate 2 files in your output directory: ``` batch-results-2024-02-07_14-30-22/ ├── results.csv └── results.html ``` `results.csv` * Spreadsheet-compatible format * Original CSV columns preserved * New CSV columns for each evaluator * `{evaluator}_score` * `{evaluator}_reasoning` * `{evaluator}_status` `results.html` * Summary dashboard with grade-level distribution and text complexity charts * Scores and reasoning for each evaluator If any evaluations fail (even after retries), only those rows will error out. The batch evaluator will skip those rows and then ultimately surface those failures in the results with an error status. ### Graceful shutdown If you press `Ctrl+C` during evaluation: * In-flight evaluations finish processing * Pending tasks are cancelled * Completed results are saved to `results-partial.*` files to preserve progress ```bash theme={null} ⚠️ Shutdown requested. Saving partial results... (Press Ctrl+C again to force quit) ✓ Saved 15 results to: ./batch-results-2024-02-07_14-30-22/ ├── results-partial.csv └── results-partial.html ``` If you press `Ctrl+C` twice to force quit immediately, you may lose in-flight results. ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Understand evaluator output fields and types. Handle configuration, validation, and API errors. # Configuration Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/past-versions/typescript-v0.6.0/configuration Legacy TypeScript SDK v0.6.0 docs for configuring evaluator constructors, including required API keys, provider defaults, and modelOverride. Import and configure the evaluator of your choice. ```typescript example.ts theme={null} import { GradeLevelAppropriatenessEvaluator } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: process.env.GOOGLE_API_KEY, }); ``` ## Options Our evaluators are validated against a particular provider and model during development. Evaluators default to that same provider and model at runtime – for example, [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) will always use Google Gemini out of the box, because it was validated against Google Gemini during development. As a result, each evaluator [requires specific API keys](/evaluators/getting-started/quickstart#required-api-keys) when being configured (e.g., `googleApiKey`, `openaiApiKey`, etc.). We recommend using the validated provider and model, but the SDK does allow you to override that default with the `modelOverride` option. | Field | Type | Description | | :---------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `googleApiKey` | `string` | Google API key, **required** for evaluators that default to Google models | | `openaiApiKey` | `string` | OpenAI API key, **required** for evaluators that default to OpenAI models | | `anthropicApiKey` | `string` | Anthropic API key, **required** for evaluators that default to Claude or when `modelOverride` is set to `Provider.Anthropic` | | `modelOverride`
v0.5.0
| [`ModelOverride`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/evaluators/base.ts) | Overrides the evaluator's default provider and model | | `maxRetries` | `number` | **Default:** `2`. Maximum retry attempts for failed evaluator calls | | `telemetry` | `boolean \|` [`TelemetryOptions`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/evaluators/base.ts) | **Default:** `true`. Configuration for collecting [telemetry](/evaluators/sdk-api-reference/typescript/configuration#telemetry) | | `logger` | [`Logger`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/logger.ts) | [Custom logger](#custom-logger) for evaluator output | | `logLevel` | [`LogLevel`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/logger.ts) | **Default:** `WARN`. [Logging verbosity level](#log-level) | | `partnerKey` | `string` | Your Learning Commons API key, used for authenticated [telemetry data collection](/evaluators/sdk-api-reference/typescript/configuration#telemetry). Create your API key on the [Learning Commons Platform](https://platform.learningcommons.org/). | Evaluators are validated and tested against their default models. Results with other models (using `modelOverride`) may vary. ## Logging Customize how your evaluator logs information. ### Log level Control logging verbosity: ```typescript theme={null} import { GradeLevelAppropriatenessEvaluator, LogLevel, } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: "...", logLevel: LogLevel.INFO, // SILENT | ERROR | WARN | INFO | DEBUG }); ``` ### Custom logger You can configure your evaluator with a custom logger: ```typescript theme={null} import { GradeLevelAppropriatenessEvaluator, type Logger, } from "@learning-commons/evaluators"; const customLogger: Logger = { debug: (msg, ctx) => myLogger.debug(msg, ctx), info: (msg, ctx) => myLogger.info(msg, ctx), warn: (msg, ctx) => myLogger.warn(msg, ctx), error: (msg, ctx) => myLogger.error(msg, ctx), }; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: "...", logger: customLogger, }); ``` ## Telemetry We collect limited usage and performance telemetry by default. This may include performance metrics (latency, token usage), technical metadata (such as SDK version and evaluator type) and related diagnostic information. This telemetry helps us improve evaluator quality, identify edge cases, and optimize performance. You can disable telemetry collection through the [configuration options](#options). ### What you'll need While telemetry data collection is not required, we recommend enabling it so that we can better support your team's use cases. Create an API key in the [Learning Commons Platform](https://platform.learningcommons.org/) ↗ and include this key in your evaluator's [configuration options](./configuration#options). **We don't collect your API keys or any user identifiers through the SDK.** ### What we collect | Field | Description | | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `timestamp` | ISO 8601 timestamp when evaluation started | | `sdk_version` | SDK version (e.g., `"0.1.0"`) | | `evaluator_type` | Which evaluator ran (e.g., `"vocabulary"`, `"sentence-structure"`) | | `grade` | Grade level evaluated (e.g., `"5"`, `"K"`) | | `status` | Evaluation outcome (`"success"` or `"error"`) | | `error_code` | Error type if status is `"error"` (e.g., `"Error"`, `"TypeError"`) | | `latency_ms` | Total evaluation time in milliseconds | | `text_length_chars` | Length of input text in characters | | `provider` | LLM provider(s) used (e.g., `"openai:gpt-4o"`, `"google:gemini-2.5-pro"`) | | `token_usage` | Total tokens consumed (input and output) | | `input_text`
Opt in
| Text being evaluated (only included if the `telemetry` [configuration option](#options) is set to `{ enabled: true, recordInputs: true }`).

Developers are responsible for ensuring that any content they choose to share complies with applicable law and does not include sensitive or regulated information unless they have appropriate authorization to provide it. | | `metadata.stage_details` | Per-stage breakdown for multi-stage evaluators (optional) | ```json payload.json theme={null} { "timestamp": "2026-02-05T19:30:00.000Z", "sdk_version": "0.1.0", "evaluator_type": "vocabulary", "grade": "3", "status": "success", "latency_ms": 3500, "text_length_chars": 456, "provider": "openai:gpt-4o-2024-11-20 + google:gemini-2.5-pro", "token_usage": { "input_tokens": 650, "output_tokens": 350 }, "metadata": { "stage_details": [ { "stage": "background_knowledge", "provider": "openai:gpt-4o-2024-11-20", "latency_ms": 1200, "token_usage": { "input_tokens": 250, "output_tokens": 150 } }, { "stage": "complexity_evaluation", "provider": "google:gemini-2.5-pro", "latency_ms": 2300, "token_usage": { "input_tokens": 400, "output_tokens": 200 } } ] } } ``` ## Related topics Install the SDK and run your first evaluator. Understand evaluator output fields and types. Handle configuration, validation, and API errors. Evaluate a batch of text from a CSV file using literacy evaluators. # Error handling Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/past-versions/typescript-v0.6.0/error-handling Legacy TypeScript SDK v0.6.0 docs for handling errors like ConfigurationError, ValidationError, RateLimitError, and TimeoutError in evaluators. The SDK provides specific error types to help you handle different scenarios. ```typescript example.ts theme={null} import { GradeLevelAppropriatenessEvaluator, ConfigurationError } from "@learning-commons/evaluators"; try { const evaluator = new GradeLevelAppropriatenessEvaluator(configOptions); const result = await evaluator.evaluate(text); } catch (error) { if (error instanceof ConfigurationError) { console.error("Fix config:", error.message); } else { ... } } ``` ## Errors | Type | Description | | --------------------- | --------------------------------------------------- | | `ConfigurationError` | Missing or invalid API keys | | `ValidationError` | Invalid input (text too short, invalid grade, etc.) | | `AuthenticationError` | Invalid API keys | | `RateLimitError` | Rate limit exceeded; wait and retry | | `NetworkError` | Network connectivity issues | | `TimeoutError` | Request timed out | | `APIError` | Other API errors | ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Understand evaluator output fields and types. Evaluate a batch of text from a CSV file using literacy evaluators. # Outputs Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/past-versions/typescript-v0.6.0/outputs Legacy TypeScript SDK v0.6.0 docs for evaluator output fields, including Text Complexity results from the full literacy evaluator family. Once you've configured your evaluator, you can start evaluating text inputs for grade level appropriateness: ```typescript example.ts theme={null} const evaluator = new GradeLevelAppropriatenessEvaluator(configOptions); const text = "The cat's out of the bag now."; await evaluator.evaluate(text); ``` ## Student-Facing Text evaluator family The Text Complexity evaluator runs multiple Student-Facing Text evaluators on the provided text input: * [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) * [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands)  v0.2.0 * [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) * [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) * [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness)  v0.3.0 * [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity)  v0.5.0 The output: * Throws an error if all Student-Facing Text evaluators fail * Otherwise outputs an error or result [for each Student-Facing Text evaluator](#for-other-evaluators) ## For other evaluators All Student-Facing Text evaluators besides the parent Text Complexity evaluator have the following output fields. | Field | Type | Description | | :---------- | :----------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `score` | [`TextComplexityLevel`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/outputs.ts) ↗ | Complexity classification returned by the evaluator. Purpose Clarity evaluator also accepts "More context needed" for cases where the text alone is insufficient to determine complexity. | | `reasoning` | `string` | Explanation for the assigned complexity score | | `metadata` | [`EvaluationMetadata`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/outputs.ts) ↗ | Includes model used to generate the evaluation, total evaluation processing time in milliseconds, input tokens, and output tokens. | | `_internal` | Unique to each evaluator | Detailed internal analysis data specific to each evaluator. | The `_internal` field includes detailed internal analysis data specific to that evaluator: | Evaluator | `_internal` description | `_internal` type | | :-------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) | [Output fields](/evaluators/student-facing-text-evaluators/grade-level-appropriateness#output) | [`GradeLevelAppropriatenessInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/grade-level-appropriateness.ts) ↗ | | [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands)
v0.2.0
| [Output fields](/evaluators/student-facing-text-evaluators/background-knowledge-demands#output) | [`SmkInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/smk.ts) ↗ | | [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) | [Output fields](/evaluators/student-facing-text-evaluators/vocabulary-complexity#output) | [`VocabularyInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/vocabulary.ts) ↗ | | [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) | [Output fields](/evaluators/student-facing-text-evaluators/sentence-structure#output) | [`SentenceStructureInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/sentence-structure.ts) ↗ | | [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness)
v0.3.0
| [Output fields](/evaluators/student-facing-text-evaluators/meaning-directness#output) | [`ConventionalityInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/conventionality.ts) ↗ | | [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity)
v0.5.0
| [Output fields](/evaluators/student-facing-text-evaluators/purpose-clarity#output) | [`PurposeInternal`](https://github.com/learning-commons-org/evaluators/blob/sdks-typescript-v0.6.0/sdks/typescript/src/schemas/purpose.ts) ↗ | ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Handle configuration, validation, and API errors. Evaluate a batch of text from a CSV file using literacy evaluators. # Configuration Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/python/configuration Configure the Python SDK with create_config, provider configs for Google, OpenAI, and Anthropic, and instantiate evaluators with your API keys. Import and configure the evaluator of your choice. ```python example.py theme={null} from learning_commons_evaluators import ( GoogleLLMProviderConfig, OpenAILLMProviderConfig, AnthropicLLMProviderConfig, GradeLevelAppropriatenessEvaluator, create_config, ) # Create provider config google_config = GoogleLLMProviderConfig(api_key="...") openai_config = OpenAILLMProviderConfig(api_key="...") anthropic_config = AnthropicLLMProviderConfig(api_key="...") # Create evaluator config # NOTE: Telemetry is not yet implemented in v0.2.0 config = create_config( google_llm_provider_config=google_config, telemetry_partner_id="your-learning-commons-api-key", ) # Instantiate evaluator evaluator = GradeLevelAppropriatenessEvaluator(config) ``` ## `create_config` methods The SDK provides several methods to create a configuration object: ```python theme={null} from learning_commons_evaluators import ( create_config, # Collects telemetry (Not yet supported) create_config_no_telemetry, # Does not collect telemetry create_config_telemetry_with_full_input, # Collects telemetry with input text (Not yet supported) ) ``` Each method takes in a list of [configuration options](#options). ## Options Our evaluators are validated against a particular provider and model during development. Evaluators default to that same provider and model at runtime – for example, [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) will always use Google Gemini out of the box, because it was validated against Google Gemini during development. As a result, each evaluator [requires specific API keys](/evaluators/getting-started/quickstart#required-api-keys) when being configured (e.g., `google_llm_provider_config`, `openai_llm_provider_config`, etc.). We recommend using the validated provider and model, but the SDK does allow you to override that default in your [per-instance settings](#per-instance-settings) or [per-call settings](#per-call-settings). Please note that your mileage may vary if you use a different model. | Field | Type | Description | | :------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `google_llm_provider_config` | [`GoogleLLMProviderConfig`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/config.py) | Google API key, required for evaluators that default to Google models | | `openai_llm_provider_config` | [`OpenAILLMProviderConfig`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/config.py) | OpenAI API key, required for evaluators that default to OpenAI models | | `anthropic_llm_provider_config` | [`AnthropicLLMProviderConfig`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/config.py) | Anthropic API key, required for evaluators that default to Claude or when overriding a default model with Claude | | `logger` | [`Logger`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/logger.py) | [Custom logger](#custom-logger) for evaluator output. Can set [logging verbosity level](#log-level). | | `telemetry_partner_id`  Not yet supported | `string` | Your Learning Commons API key, used for authenticated and anonymous [telemetry data collection](/evaluators/sdk-api-reference/python/configuration#telemetry). **Required** for `create_config` and `create_config_telemetry_with_full_input` only | ## Logging Customize how your evaluator logs information. ### Log level Control logging verbosity: ```python theme={null} # SDK uses Python's standard logging module import logging # By default, EvaluatorConfig uses the package logger, # which propagates to the root logger once your app configures handlers logging.basicConfig(level=logging.DEBUG) logging.getLogger("learning_commons_evaluators").setLevel(logging.WARNING) from learning_commons_evaluators import ( create_config_no_telemetry, create_logger, create_silent_logger, ) logger = create_logger(level=logging.DEBUG) # Discards logs + does not send as telemetry data config = create_config_no_telemetry(logger=create_silent_logger()) ``` ### Custom logger You can configure your evaluator with a custom logger: ```python theme={null} import logging from learning_commons_evaluators import ( create_config, ) # Route SDK logs through your own logger my_logger = logging.getLogger("my_app.evaluators") custom_logger_config = create_config(..., logger=my_logger) ``` ## Per-instance settings Override the default for every call on a particular evaluator instance using `default_evaluation_settings`. [Per-call settings](#per-call-settings) will override per-instance settings for a single run. ```python theme={null} from dataclasses import replace from learning_commons_evaluators import GradeLevelAppropriateness settings = GradeLevelAppropriateness.default_evaluation_settings.model_copy(deep=True) settings.prompt_settings_step_gla_evaluation = replace( settings.prompt_settings_step_gla_evaluation, temperature=0.2, model="gemini-2.5-pro", ) evaluator = GradeLevelAppropriateness(config, default_evaluation_settings=settings) result = evaluator.evaluate_sync(input) # uses instance default ``` ## Per-call settings Override models, temperatures, or other configurable evaluator settings for a single run using `evaluation_settings`: ```python theme={null} from dataclasses import replace from learning_commons_evaluators import GradeLevelAppropriateness evaluator = GradeLevelAppropriateness(config) settings = evaluator.default_evaluation_settings.model_copy(deep=True) settings.prompt_settings_step_gla_evaluation = replace( settings.prompt_settings_step_gla_evaluation, temperature=0.2, ) result = evaluator.evaluate_sync(input, evaluation_settings=settings) ``` When omitted, the evaluator uses a deep copy of its default settings. ## Related topics Install the SDK and run your first evaluator. Understand evaluator output fields and types. Handle configuration, validation, and API errors. # Error handling Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/python/error-handling Handle Python SDK EvaluatorError types like ConfigurationError, InputValidationError, and RateLimitError, using the retryable attribute to retry. The SDK provides specific error types to help you handle different scenarios. ```python example.py theme={null} import time from learning_commons_evaluators import EvaluatorError, RateLimitError for attempt in range(3): try: result = evaluator.evaluate_sync(input) break except EvaluatorError as e: # Every EvaluatorError exposes a boolean retryable attribute if not e.retryable or attempt == 2: raise delay = e.retry_after if isinstance(e, RateLimitError) and e.retry_after else 2 ** attempt # retry_after is in seconds time.sleep(delay) ``` ## `EvaluatorError` Evaluators can throw 3 types of `EvaluatorError`s: | Type | Description | | ---------------------- | --------------------------------------------------- | | `ConfigurationError` | Missing or invalid API keys | | `InputValidationError` | Invalid input (text too short, invalid grade, etc.) | | `APIError` | Other API errors ([Subtypes](#apierror)) | ## `APIError` `APIError`s can be broken down further into more specific error types: | Type | Description | | ----------------------- | ---------------------------------------------------------- | | `AuthenticationError` | Invalid API keys | | `RateLimitError` | Rate limit exceeded; wait and retry | | `NetworkError` | Network connectivity issues | | `RequestTimeoutError` | Request timed out | | `OutputValidationError` | Output failed to parse or didn't match the expected schema | ## Retries Every `EvaluatorError` exposes a boolean `retryable` attribute: | Retryable by default | Not retryable by default | | --------------------------------- | --------------------------------- | | `RateLimitError` | `ConfigurationError` | | `NetworkError` | `InputValidationError` | | `RequestTimeoutError` | `AuthenticationError` | | `OutputValidationError` | `APIError` with a 4xx status code | | `APIError` with a 5xx status code | | To flag a specific instance (e.g., a permanently-bad hostname), `APIError`s and `NetworkError`s also accept `retryable` as an **init** kwarg. `APIError`s with status code >= 500 and an unspecified `retryable` attribute will default to `retryable: True`. ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Understand evaluator output fields and types. # Outputs Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/python/outputs Understand output fields returned by Python SDK literacy evaluators, with examples of evaluating text for grade level appropriateness. Once you've configured your evaluator, you can start evaluating text inputs for grade level appropriateness: ```python example.py theme={null} from learning_commons_evaluators import ( GradeLevelAppropriatenessEvaluator, GradeLevelAppropriatenessEvaluationInput, GooglePromptProviderConfig, create_config, ) # Create evaluator config # NOTE: Telemetry is not yet implemented in v0.2.0 config = create_config( google_llm_provider_config=GooglePromptProviderConfig(api_key="your-google-key"), telemetry_partner_id="your-learning-commons-api-key", ) # Instantiate evaluator evaluator = GradeLevelAppropriatenessEvaluator(config) # Evaluate text for grade level appropriateness result = evaluator.evaluate( GradeLevelAppropriatenessEvaluationInput(text="The cat's out of the bag now.") ) ``` ## Student-Facing Text evaluators The Student-Facing Text evaluators have the following output fields: | Field | Type | Description | | :------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- | | `answer` | [`EvaluationAnswer`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/evaluator.py) ↗ | Complexity score returned by the evaluation | | `explanation` | [`EvaluationExplanation`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/evaluator.py) ↗ | Reasoning for the complexity score and evaluator-specific fields (`explanation.details` – see table below) | | `metadata` | [`EvaluationMetadata`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/metadata.py) ↗ | Evaluation run metadata like timing, status, token usage, and per-step details | The `explanation.details` field includes detailed internal analysis data specific to that evaluator. | Evaluator | `explanation.details` description | `explanation.details` type | | :--------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness)  v0.2.0 | [Output fields](/evaluators/student-facing-text-evaluators/grade-level-appropriateness#output) | [`GradeLevelAppropriatenessOutput`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/grade_level_appropriateness.py) ↗ | | [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) | [Output fields](/evaluators/student-facing-text-evaluators/vocabulary-complexity#output) | [`VocabularyComplexityOutput`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/vocabulary.py) | | [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness) | [Output fields](/evaluators/student-facing-text-evaluators/meaning-directness#output) | [`ConventionalityOutput`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/schemas/conventionality.py) | ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Handle configuration, validation, and API errors. # Batch evaluator Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/typescript/batch-evaluator Evaluate a batch of text from a CSV file using all Student-Facing Text evaluators. Results are output in both CSV and HTML format.
v0.4.0
## What you'll do Evaluate a batch of text from a CSV file using all [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction). Results are output in both CSV and HTML format. ## What you'll need * Install the SDK globally ```bash theme={null} npm install -g @learning-commons/evaluators ``` * Create a CSV file with the text you want to evaluate * Must be 50 or fewer input rows (unless using the [`--bypass-row-limit` option](#options)) * Must have `text` and `grade` columns * May include additional columns (will be preserved as-is in the output) ```csv example.csv theme={null} text,grade "The cat sat on the mat.",3 "Photosynthesis is the process by which plants convert sunlight into energy.",5 "The mitochondria are the powerhouse of the cell.",8 ``` ## Running the batch evaluator Run the batch evaluator using `npx` from any directory: ```bash theme={null} # Pass the CSV path with the required API key(s) + output directory npx evaluators-batch input.csv \ --google-api-key $GOOGLE_API_KEY \ --openai-api-key $OPENAI_API_KEY \ --output-dir ./batch-results npx evaluators-batch --help # Lists all options npx evaluators-batch --version # Prints SDK version ``` ### Interactive prompts If you omit a required input, the CLI prompts you interactively for the CSV file path, API keys, and/or output directory. Before starting evaluations, the CLI always shows a confirm prompt. This intentional safety checkpoint helps prevent accidental expensive runs. ### Options Pass options to override the batch evaluator's defaults: ```bash theme={null} evaluators-batch input.csv \ --concurrency 5 \ --max-retries 3 \ --model anthropic:claude-opus-4-8 \ --no-telemetry ``` | Option | Default | Description | | :----------------------------------------------------------- | :--------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- | | ``
v0.7.0
| | Positional argument for the input CSV file path | | `--help`
v0.7.0
| | Lists all flags and usage information | | `--version`
v0.7.0
| | Prints the SDK version | | `--google-api-key `
v0.7.0
| `GOOGLE_API_KEY` environment variable | Google API key | | `--openai-api-key `
v0.7.0
| `OPENAI_API_KEY` environment variable | OpenAI API key | | `--anthropic-api-key `
v0.7.0
| `ANTHROPIC_API_KEY` environment variable | Anthropic API key | | `--model `
v0.7.0
| Evaluator's default provider and model | Global model override for an evaluator (e.g., `--model anthropic:claude-opus-4-8`)

When set, only the `--model` provider's API key is required. | | `--output-dir `
v0.7.0
| Timestamped folder | Output directory path | | `--concurrency ` | `3` | Number of evaluations to run in parallel

If you have higher rate limits with your provider and model, raise this value for faster execution. | | `--max-retries ` | `2` | Number of times to retry a failed evaluation | | `--no-telemetry` | | Disables telemetry data collection | | `--bypass-row-limit`
v0.6.0
| | Evaluates a CSV file with more than 50 rows | When the run completes, the CLI prints the full path to the HTML report so you can open it directly. ### Results You'll see a real-time display of the batch evaluator's progress: ``` Processing evaluations... ████████████░░░░░░░░ 60% (30/50) ✓ grade-level-appropriateness: 6/10 successful ✓ background-knowledge-demands: 6/10 successful ✓ vocabulary: 6/10 successful ✓ sentence-structure: 6/10 successful ⏳ conventionality: 6/10 successful ⏱ Elapsed: 2m 15s | Estimated remaining: 1m 30s ``` The batch evaluator will generate 2 files in your output directory: ``` batch-results-2024-02-07_14-30-22/ ├── results.csv └── results.html ``` `results.csv` * Spreadsheet-compatible format * Original CSV columns preserved * New CSV columns for each evaluator * `{evaluator}_score` * `{evaluator}_reasoning` * `{evaluator}_status` `results.html` * Summary dashboard with grade-level distribution and text complexity charts * Scores and reasoning for each evaluator If any evaluations fail (even after retries), only those rows will error out. The batch evaluator will skip those rows and then ultimately surface those failures in the results with an error status. ### Graceful shutdown If you press `Ctrl+C` during evaluation: * In-flight evaluations finish processing * Pending tasks are cancelled * Completed results are saved to `results-partial.*` files to preserve progress ```bash theme={null} ⚠️ Shutdown requested. Saving partial results... (Press Ctrl+C again to force quit) ✓ Saved 15 results to: ./batch-results-2024-02-07_14-30-22/ ├── results-partial.csv └── results-partial.html ``` If you press `Ctrl+C` twice to force quit immediately, you may lose in-flight results. ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Understand evaluator output fields and types. Handle configuration, validation, and API errors. # Configuration Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/typescript/configuration Configure evaluator constructors in the TypeScript SDK, including required API keys, provider and model defaults, and the modelOverride option. Import and configure the evaluator of your choice. ```typescript example.ts theme={null} import { GradeLevelAppropriatenessEvaluator } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: process.env.GOOGLE_API_KEY, }); ``` ## Options Our evaluators are validated against a particular provider and model during development. Evaluators default to that same provider and model at runtime – for example, [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) will always use Google Gemini out of the box, because it was validated against Google Gemini during development. As a result, each evaluator [requires specific API keys](/evaluators/getting-started/quickstart#required-api-keys) when being configured (e.g., `googleApiKey`, `openaiApiKey`, etc.). We recommend using the validated provider and model, but the SDK does allow you to override that default with the `modelOverride` option. | Field | Type | Description | | :---------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `googleApiKey` | `string` | Google API key, **required** for evaluators that default to Google models | | `openaiApiKey` | `string` | OpenAI API key, **required** for evaluators that default to OpenAI models | | `anthropicApiKey` | `string` | Anthropic API key, **required** for evaluators that default to Claude or when `modelOverride` is set to `Provider.Anthropic` | | `modelOverride`
v0.5.0
| [`ModelOverride`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/base.ts) | Overrides the evaluator's default provider and model | | `maxRetries` | `number` | **Default:** `2`. Maximum retry attempts for failed evaluator calls | | `telemetry` | `boolean \|` [`TelemetryOptions`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/base.ts) | **Default:** `true`. Configuration for collecting [telemetry](/evaluators/sdk-api-reference/typescript/configuration#telemetry) | | `logger` | [`Logger`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/logger.ts) | [Custom logger](#custom-logger) for evaluator output | | `logLevel` | [`LogLevel`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/logger.ts) | **Default:** `WARN`. [Logging verbosity level](#log-level) | | `partnerKey` | `string` | Your Learning Commons API key, used for authenticated [telemetry data collection](/evaluators/sdk-api-reference/typescript/configuration#telemetry). Create your API key on the [Learning Commons Platform](https://platform.learningcommons.org/). | Evaluators are validated and tested against their default models. Results with other models (using `modelOverride`) may vary. ## Logging Customize how your evaluator logs information. ### Log level Control logging verbosity: ```typescript theme={null} import { VocabularyEvaluator, LogLevel } from "@learning-commons/evaluators"; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: "...", logLevel: LogLevel.INFO, // SILENT | ERROR | WARN | INFO | DEBUG }); ``` ### Custom logger You can configure your evaluator with a custom logger: ```typescript theme={null} import type { Logger } from "@learning-commons/evaluators"; const customLogger: Logger = { debug: (msg, ctx) => myLogger.debug(msg, ctx), info: (msg, ctx) => myLogger.info(msg, ctx), warn: (msg, ctx) => myLogger.warn(msg, ctx), error: (msg, ctx) => myLogger.error(msg, ctx), }; const evaluator = new GradeLevelAppropriatenessEvaluator({ googleApiKey: "...", logger: customLogger, }); ``` ## Telemetry We collect limited usage and performance telemetry by default. This may include performance metrics (latency, token usage), technical metadata (such as SDK version and evaluator type) and related diagnostic information. This telemetry helps us improve evaluator quality, identify edge cases, and optimize performance. You can disable telemetry collection through the [configuration options](#options). ### What you'll need While telemetry data collection is not required, we recommend enabling it so that we can better support your team's use cases. Create an API key in the [Learning Commons Platform](https://platform.learningcommons.org/) ↗ and include this key in your evaluator's [configuration options](./configuration#options). **We don't collect your API keys or any user identifiers through the SDK.** ### What we collect | Field | Description | | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `timestamp` | ISO 8601 timestamp when evaluation started | | `sdk_version` | SDK version (e.g., `"0.1.0"`) | | `evaluator_type` | Which evaluator ran (e.g., `"vocabulary"`, `"sentence-structure"`) | | `grade` | Grade level evaluated (e.g., `"5"`, `"K"`) | | `status` | Evaluation outcome (`"success"` or `"error"`) | | `error_code` | Error type if status is `"error"` (e.g., `"Error"`, `"TypeError"`) | | `latency_ms` | Total evaluation time in milliseconds | | `text_length_chars` | Length of input text in characters | | `provider` | LLM provider(s) used (e.g., `"openai:gpt-4o"`, `"google:gemini-2.5-pro"`) | | `token_usage` | Total tokens consumed (input and output) | | `input_text`
Opt in
| Text being evaluated (only included if the `telemetry` [configuration option](#options) is set to `{ enabled: true, recordInputs: true }`).

Developers are responsible for ensuring that any content they choose to share complies with applicable law and does not include sensitive or regulated information unless they have appropriate authorization to provide it. | | `metadata.stage_details` | Per-stage breakdown for multi-stage evaluators (optional) | ```json payload.json theme={null} { "timestamp": "2026-02-05T19:30:00.000Z", "sdk_version": "0.1.0", "evaluator_type": "vocabulary", "grade": "3", "status": "success", "latency_ms": 3500, "text_length_chars": 456, "provider": "openai:gpt-4o-2024-11-20 + google:gemini-2.5-pro", "token_usage": { "input_tokens": 650, "output_tokens": 350 }, "metadata": { "stage_details": [ { "stage": "background_knowledge", "provider": "openai:gpt-4o-2024-11-20", "latency_ms": 1200, "token_usage": { "input_tokens": 250, "output_tokens": 150 } }, { "stage": "complexity_evaluation", "provider": "google:gemini-2.5-pro", "latency_ms": 2300, "token_usage": { "input_tokens": 400, "output_tokens": 200 } } ] } } ``` ## Related topics Install the SDK and run your first evaluator. Understand evaluator output fields and types. Handle configuration, validation, and API errors. Evaluate a batch of text from a CSV file using literacy evaluators. # Error handling Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/typescript/error-handling Handle TypeScript SDK errors like ConfigurationError, ValidationError, RateLimitError, and TimeoutError when running evaluators in your app. The SDK provides specific error types to help you handle different scenarios. ```typescript example.ts theme={null} import { GradeLevelAppropriatenessEvaluator, ConfigurationError } from "@learning-commons/evaluators"; try { const evaluator = new GradeLevelAppropriatenessEvaluator(configOptions); const result = await evaluator.evaluate(text); } catch (error) { if (error instanceof ConfigurationError) { console.error("Fix config:", error.message); } else { ... } } ``` ## Errors | Type | Description | | --------------------- | --------------------------------------------------- | | `ConfigurationError` | Missing or invalid API keys | | `ValidationError` | Invalid input (text too short, invalid grade, etc.) | | `AuthenticationError` | Invalid API keys | | `RateLimitError` | Rate limit exceeded; wait and retry | | `NetworkError` | Network connectivity issues | | `TimeoutError` | Request timed out | | `APIError` | Other API errors | ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Understand evaluator output fields and types. Evaluate a batch of text from a CSV file using literacy evaluators. # Outputs Source: https://docs.learningcommons.org/evaluators/sdk-api-reference/typescript/outputs Understand output fields returned by TypeScript SDK evaluators, including Text Complexity results from the full literacy evaluator family. Once you've configured your evaluator, you can start evaluating text inputs for grade level appropriateness: ```typescript example.ts theme={null} const evaluator = new GradeLevelAppropriatenessEvaluator(configOptions); const text = "The cat's out of the bag now."; await evaluator.evaluate(text); ``` ## Student-Facing Text evaluator family The Text Complexity evaluator runs multiple Student-Facing Text evaluators on the provided text input: * [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) * [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands)  v0.2.0 * [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) * [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) * [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness)  v0.3.0 * [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity)  v0.5.0 The output: * Throws an error if all Student-Facing Text evaluators fail * Otherwise outputs an error or result [for each Student-Facing Text evaluator](#for-other-evaluators) ## For other evaluators All Student-Facing Text evaluators besides the parent Text Complexity evaluator have the following output fields. | Field | Type | Description | | :---------- | :----------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `score` | [`TextComplexityLevel`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/outputs.ts) ↗ | Complexity classification returned by the evaluator. Purpose Clarity evaluator also accepts "More context needed" for cases where the text alone is insufficient to determine complexity. | | `reasoning` | `string` | Explanation for the assigned complexity score | | `metadata` | [`EvaluationMetadata`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/outputs.ts) ↗ | Includes model used to generate the evaluation, total evaluation processing time in milliseconds, input tokens, and output tokens. | | `_internal` | Unique to each evaluator | Detailed internal analysis data specific to each evaluator. | The `_internal` field includes detailed internal analysis data specific to that evaluator: | Evaluator | `_internal` description | `_internal` type | | :-------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness) | [Output fields](/evaluators/student-facing-text-evaluators/grade-level-appropriateness#output) | [`GradeLevelAppropriatenessOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/grade-level-appropriateness.ts) ↗ | | [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands)
v0.2.0
| [Output fields](/evaluators/student-facing-text-evaluators/background-knowledge-demands#output) | [`BackgroundKnowledgeDemandsOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/background-knowledge-demands.ts) ↗ | | [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) | [Output fields](/evaluators/student-facing-text-evaluators/vocabulary-complexity#output) | [`VocabularyComplexityOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/vocabulary-complexity.ts) ↗ | | [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure) | [Output fields](/evaluators/student-facing-text-evaluators/sentence-structure#output) | [`SentenceStructureOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/sentence-structure.ts) ↗ | | [Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness)
v0.3.0
| [Output fields](/evaluators/student-facing-text-evaluators/meaning-directness#output) | [`MeaningDirectnessOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/meaning-directness.ts) ↗ | | [Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity)
v0.5.0
| [Output fields](/evaluators/student-facing-text-evaluators/purpose-clarity#output) | [`PurposeClarityOutputSchema`](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/schemas/student-facing-text/ela-reading/purpose-clarity.ts) ↗ | ## Related topics Install the SDK and run your first evaluator. Configure evaluators, including API keys and options. Handle configuration, validation, and API errors. Evaluate a batch of text from a CSV file using literacy evaluators. # Background Knowledge Demands Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/background-knowledge-demands Measure how much prior knowledge a reading passage assumes, listing key concepts and whether students at a grade level have likely encountered them. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Background Knowledge Demands evaluator assesses the background knowledge complexity of reading passages: * Evaluates how much prior knowledge a text relies on * Lists key concepts in the text * Evaluates whether students have likely encountered these concepts before ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Supported grades** | 3-12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------------------ | | **Model used** | Gemini 3 Flash preview (`gemini-3-flash-preview`) | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/background-knowledge-demands.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/background-knowledge-demands/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/background-knowledge-demands/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/background-knowledge-demands/user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Identified topics** | Core subjects and concepts found in the text | | **Curriculum check** | Whether the topics are standard K-8 knowledge or specialized high-school-level knowledge | | **Assumptions and scaffolding** | What the author assumes the reader already knows versus what is explained in the text | | **Friction analysis** | Whether difficulty comes from vocabulary/sentence structure or from actual background knowledge demands | | **Complexity rating** |
  • Slightly complex: Relies on everyday, practical knowledge; includes simple, concrete ideas
  • Moderately complex: Relies on common practical knowledge and some discipline-specific content knowledge; includes a mix of simple and more complicated, abstract ideas
  • Very complex: Relies on moderate levels of discipline-specific or theoretical knowledge; includes a mix of recognizable ideas and challenging abstract concepts
  • Exceedingly complex: Relies on extensive levels of discipline-specific or theoretical knowledge; includes a range of challenging abstract concepts
| | **Reasoning** | Synthesized explanation of the decision | ## Interpreting results | Output | How to use | | :-------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Complexity rating** |
  • Slightly complex: Confirm text relies on everyday knowledge students likely have
  • Moderately complex: Plan light scaffolding for discipline-specific terms
  • Very complex: Pre-teach key concepts before independent reading
  • Exceedingly complex: Flag texts that assume extensive prior knowledge
| | **Identified topics + Assumptions and scaffolding** | Match text to what students have already encountered

**Example**: Use identified topics, curriculum check, and friction analysis to decide what to pre-teach or explain in the text | ## Evaluator release history | Date | Changed | | --------------- | -------------------- | | August 27, 2026 | Minor prompt updates | | March 13, 2026 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Grade Level Appropriateness Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/grade-level-appropriateness Test whether AI-generated text suits independent reading at a target grade band using readability, vocabulary, structure, and knowledge demand checks. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Grade Level Appropriateness evaluator assesses whether AI-generated text is suitable for independent reading at a specified grade band. The evaluator considers: * Flesch-Kincaid grade level * Word count * Text structure – Organization complexity, connections between ideas, text features * Language features – Vocabulary, sentence complexity, figurative vs. abstract * Purpose – Explicitly vs. not explicitly stated, concrete vs. abstract * Knowledge demands – Discipline-specific knowledge, references, allusions * Student background knowledge – What students at a given grade level would already know ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate | | **Supported grades** | K–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------ | | **Model used** | Gemini 3.6 Flash (`gemini-3.6-flash`) | | **Temperature** | 1 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [Python](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/evaluators/grade_level_appropriateness.py) ↗ and [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/grade-level-appropriateness.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/grade-level-appropriateness/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/grade-level-appropriateness/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/grade-level-appropriateness/user.txt) ↗) | ## Inputs | Input | Description | Required | | :------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | ## Output | Field | Description | | :------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------ | | **Reasoning** | Reasoning for the output grade level (quantitative score, qualitative features, assumed background knowledge), followed by a synthesis | | **Grade band** | Target grade band for the text at independent reading | | **Alternative grade band** | Grade band that could read and comprehend the text with scaffolding, or as a read-aloud | | **Scaffolding needed** | Scaffolding (picture, graph, additional context, vocabulary pre-teaching, etc.) that would make the text accessible at the alternative grade band | ## Interpreting results | Output | How to use | | :----------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Grade + Reasoning** | Evaluate and improve the complexity of your AI-generated content

**Example**: Validate that your LLM prompts produce grade-appropriate content; aggregate reasoning across runs to diagnose and fix systemic complexity issues | | **Alternative grade + Scaffolding needed** | Adapt content for a wider range of learners

**Example**: Make scaffolding suggestions (e.g., vocabulary pre-teaching, read-aloud) to help educators adapt content for mixed classrooms | ## Evaluator release history | Date | Changed | | ------------------ | -------------------- | | August 27, 2026 | Minor prompt updates | | September 23, 2025 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Introduction Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/introduction Overview of Student-Facing Text evaluators that measure qualitative text complexity, from sentence structure and vocabulary to grade-level fit. ## The problem [Research](https://achievethecore.org/content/upload/Research%20Supporting%20the%20ELA%20Standards%20and%20Shifts%20Final.pdf) ↗ shows that students who consistently engage with complex texts are more likely to succeed in college and beyond. Yet despite their importance, complex texts often remain absent from classrooms. * Quantitative measures of text complexity (e.g., Lexile or Flesch-Kincaid) are useful, but limited * Qualitative measures are more accurate, but also more labor-intensive to assess As AI-generated texts enter the classroom, **educators risk using content that looks grade-appropriate on the surface, but fails to meet the deeper demands of literacy development.** ## What we're building Instead of giving a single complexity score, our Student-Facing Text evaluators assess text across multiple qualitative dimensions. They are anchored in Student Achievement Partners (SAP)'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗, giving you: * Fine-grained data to ensure quality generated texts * Actionable insights into why a text may be complex or not complex enough and how to best scaffold it for students | Evaluator | SAP rubric dimension | Description | | :------------------------------------------------------------------------------------------------------------------------------------ | :-------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------ | | **[Grade Level Appropriateness](/evaluators/student-facing-text-evaluators/grade-level-appropriateness)
** | All dimensions | Determines whether AI-generated text is suitable for a grade band and suggests scaffolding that can support instruction of the text | | **[Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands)
** | Subject Matter Knowledge | Identifies the background knowledge a student needs to comprehend the generated text | | **[Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity)
** | Vocabulary | Measures how challenging students may find the vocabulary of AI-generated texts | | **[Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure)
** | Sentence Structure | Assesses the complexity of sentence structure in informational texts relative to a specified grade level | | **[Meaning Directness](/evaluators/student-facing-text-evaluators/meaning-directness)
** | Conventionality | Analyzes how directly a text communicates its meaning | | **[Purpose Clarity](/evaluators/student-facing-text-evaluators/purpose-clarity)
** | Purpose | Assesses how clearly a text communicates its central purpose, and identifies elements that make that purpose accessible or challenging to readers | | **[Organizational Structure](/evaluators/student-facing-text-evaluators/organizational-structure)
** | Organization | Assesses how demanding a text's organizational structure is for students at a given grade level | | **[Reference Knowledge Demands](/evaluators/student-facing-text-evaluators/reference-knowledge-demands)
** | Intertextuality | Assesses what a text assumes you've already encountered and then builds on to create meaning | Explore our [Student-Facing Text dataset](/evaluators/dataset/student-facing-text) for the benchmark data that our Student-Facing Text evaluators use to assess text complexity. ## Scope and limitations Student-Facing Text evaluator outputs should not be used for high-stakes applications like grading, assessment, or placement decisions without human review. Remember that LLM scores can vary across runs, especially on borderline cases. We recommend keeping a human in the loop and treating outputs as directional signals vs. definitive judgments. ## Related topics Explore the expert-annotated benchmark behind Student-Facing Text evaluators. Integrate Student-Facing Text evaluators into your TypeScript or Python project. Explore evaluators that assess the quality of coaching feedback. Explore evaluators that assess content alignment to academic standards. # Meaning Directness Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/meaning-directness Measure how literal or figurative a text's language is with the Conventionality evaluator, scoring text complexity for grades 3-12 informational text. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Meaning Directness evaluator assesses how directly a text communicates its meaning. It analyzes whether language is literal and explicit or relies on figurative, abstract, or implied meaning that requires interpretation. ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------------------ | | **Model used** | Gemini 3 Flash preview (`gemini-3-flash-preview`) | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [Python](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/evaluators/conventionality.py) ↗ and [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/meaning-directness.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/meaning-directness/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/meaning-directness/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/meaning-directness/user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Complexity rating** |
  • Slightly complex: Confirm generated text uses literal, grade-appropriate language
    • Language is literal and explicit
    • Meaning is directly stated
    • Minimal use of abstract, symbolic, ironic, and/or figurative language
    • Almost entirely explicit, literal, and straightforward
  • Moderately complex: Check whether occasional figurative language fits instructional goals
    • Mostly literal language with occasional figurative or implicit meaning
    • Occasional use of abstract, symbolic, ironic, and/or figurative language
    • Primarily explicit, literal and straightforward
  • Very complex: Plan scaffolding when figurative language is central to meaning
    • Frequent figurative language or implied meaning requires interpretation
    • Frequent use of abstract, symbolic, ironic, and/or figurative language
  • Exceedingly complex: Flag texts that require heavy interpretive support before use
    • Language relies heavily on abstraction, layered meaning, or sustained figurative expression
    • Pervasive use of abstract, symbolic, ironic, and/or figurative language
| | **Reasoning** | Explanation of the rating based on language features | | **Meaning Directness features** | Specific language features driving complexity (for example, idioms, metaphors, irony, or implicit meaning) | | **Grade context** | Comparison of meaning directness demands with expectations for the provided grade | | **Instructional insights** | Suggestions for scaffolding or teaching unconventional language features

**Example**: Use meaning directness features, grade context, and reasoning together to identify which language features to pre-teach or clarify | ## Evaluator release history | Date | Changed | | --------------- | -------------------- | | August 27, 2026 | Minor prompt updates | | March 20, 2026 | First release | # Organizational Structure Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/organizational-structure Rate the structural complexity of informational texts, from chronological to cause-and-effect patterns, against grade-level reading expectations. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Organizational Structure evaluator assesses the structural complexity of an informational text — whether its ideas are arranged in a clear, predictable sequence with explicit connections, or woven into an intricate structure that asks the reader to infer how the pieces relate. Two texts can share the same vocabulary, sentence length, and grade-level reading score, yet place very different demands on a reader depending on how they're organized. The Organizational Structure evaluator surfaces this dimension directly, so developers can optimize prompts, match texts to instructional goals, and maintain quality at scale. The evaluator works in 2 steps: 1. **Identify structure** – Detects the organizational pattern(s) a text uses to arrange its ideas and how explicitly it signals the connections between them | | | | ----------------------------- | ---------------------------------------------------------------------------------------------------- | | Chronological | Events presented in time order | | Sequential | Steps or stages presented in order | | Cause-and-effect | One or more causes linked to outcomes | | Compare-and-contrast | Similarities and differences between two or more things | | Problem-solution | A problem framed and addressed | | Discipline-specific / braided | Multiple patterns operating at once (e.g., the problem–method–results arc common in science writing) | 2. **Evaluate structural demand** – Weighs those structural demands against what students at the target grade are expected to navigate independently ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :--------------- | :----------------------------------------------------------------------------------- | | **Model used** | Gemini 3 Flash preview (`gemini-3-flash-preview`) | | **Temperature** | 1 | | **Optimization** | Prompts tuned with DSPy using the GEPA algorithm against an expert-annotated dataset | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/organizational-structure/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/organizational-structure/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/organizational-structure/user.txt) ↗) | ## Inputs | Requirement | Supported | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :----------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Complexity score** | Organizational structure's complexity level:
  • Slightly complex - Clear and predictable, with explicit connections between ideas (e.g., signaled chronological or sequential order)
  • Moderately complex - Mostly predictable, but some connections between ideas are left implicit or require the reader to infer a shift
  • Very complex - Shifts between patterns without signaling the move, braids multiple structures together, or leaves the main idea distributed across the passage
  • Exceedingly complex - Relies on multiple interacting, largely implicit patterns that the reader must reconstruct with little to no explicit signaling
| | **Reasoning** | High-level summary of why the text is at this organizational complexity level for the target grade | | **Details** | Individual complexity factors driving the rating, with a description of each and its effect on the organization dimension | | **Adjustment and scaffolding** | Analysis of what the author assumes the reader already knows versus what is explicitly explained | | **Recommended use cases** | Additional instructional opportunities suggested by the text's organizational profile | ## Evaluator release history | Date | Changed | | --------------- | -------------------- | | August 27, 2026 | Minor prompt updates | | July 29, 2026 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Purpose Clarity Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/purpose-clarity Evaluate how clearly a text states its purpose to inform, persuade, or explain, and whether intent is explicit, implied, or masked, for grades 3-12. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Purpose Clarity evaluator assesses how clearly a text communicates its central purpose – whether it is to inform, persuade, explain, describe, or entertain. The evaluator analyzes whether a text's intent is explicitly stated, indirectly hinted at, or masked (e.g., text may present as neutral information, but be building a persuasive argument). ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Passage length** | 200 words or more | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------------------ | | **Model used** | Gemini 3 Flash preview (`gemini-3-flash-preview`) | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/purpose-clarity.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/purpose-clarity/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/purpose-clarity/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/purpose-clarity/user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Allows grade-specific complexity guidance | Yes | ## Output | Field | Description | | :------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Complexity score** | Purpose complexity level:
  • Slightly complex: Purpose is explicitly stated, clear, concrete, and narrowly focused
  • Moderately complex: Purpose is implied, but easy to identify based upon context or source
  • Very complex: Purpose is implicit or subtle but fairly easy to infer; more theoretical or abstract than concrete
  • Exceedingly complex: Purpose is subtle and intricate, difficult to determine; includes many theoretical or abstract elements
  • More context needed: The passage is too short to determine its purpose. A longer portion of text or different text is needed.
| | **Reasoning** | High-level summary of why the text is at this complexity level for the target grade | | **Details** | Suggestions for adjusting the text or scaffolding students to make it appropriate for the target grade | ## Interpreting results High or low complexity scores are not inherently good or bad. A higher complexity score simply indicates a text that requires more interpretation by readers. **Example:** A "Very complex" or "Exceedingly complex" text may be ideal if the instructional goal is identifying implicit or persuasive intent. However, that same text may not be a good fit if the instructional goal is content comprehension. ## Evaluator release history | Date | Changes | | --------------- | -------------------- | | August 27, 2026 | Minor prompt updates | | May 7, 2026 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Reference Knowledge Demands Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/reference-knowledge-demands Score how much a text's meaning relies on prior references, genre conventions, and cultural knowledge with the Intertextuality complexity evaluator. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Reference Knowledge Demands evaluator assesses how much a text's meaning depends on relational knowledge – i.e., what a text assumes students have already encountered (from another text, a cultural reference, genre conventions, etc.) and then builds on to create meaning. Reference knowledge demands are one of the least visible qualitative dimensions of text complexity – unlike [Vocabulary Complexity](/evaluators/student-facing-text-evaluators/vocabulary-complexity) or [Sentence Structure](/evaluators/student-facing-text-evaluators/sentence-structure), there is no word to flag or clause to count. Reference Knowledge Demands is distinct from [Background Knowledge Demands](/evaluators/student-facing-text-evaluators/background-knowledge-demands): * **Background Knowledge Demands** – Content that a text assumes (facts, concepts, domain knowledge) * **Reference Knowledge Demands** – Relational knowledge that a text assumes (prior encounters with texts, references and conventions) ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Passage length** | 200 words or more | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :------------------------------------------------ | | **Model used** | Gemini 3 Flash preview (`gemini-3-flash-preview`) | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/reference-knowledge-demands/example_notebook.ipynb) ↗
Prompts ([`system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/reference-knowledge-demands/system.txt) ↗ and [`user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/reference-knowledge-demands/user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Complexity score** | Reference Knowledge Demands complexity level, based on how many references or allusions are present, how central they are to meaning, and how widely accessible they are likely to be for students at the target grade.
  • Slightly complex
    • Few or no intertextual references
    • Any present are explained in the text or widely familiar
    • Meaning is self-contained
  • Moderately complex
    • Some references, allusions, or genre conventions
    • Generally accessible at grade level
    • Meaning is enriched but not dependent on them
  • Very complex
    • Multiple references central to meaning
    • Assumes familiarity with texts, cultural touchstones, or genre conventions not introduced in the text
  • Exceedingly complex
    • Dense, layered references essential to meaning
    • Assumes deep familiarity with a body of texts, traditions, or discourse not part of the text
    • Largely inaccessible without prior encounters
| | **Reasoning** | Synthesized decision that explains the rating and relevant context, cites specific references and their impact on comprehension, etc. | | **Detailed summary** | Individual factors that drive the rating (specific references, allusions, genre conventions, and shared discourse detected, with descriptions and their effect on reference knowledge demand) | | **Assumptions and scaffolding** | Analysis of what the author assumes the reader already knows versus what the text explains, with suggestions for making the demands accessible | | **Recommended use cases** | Instructional opportunities for using the text and its reference knowledge demands strategically | ## Interpreting results High or low complexity scores are not inherently good or bad. A higher complexity score simply indicates a text whose meaning depends more substantially on prior cultural or textual encounters. **Example:** A "Very complex" or "Exceedingly complex" text may be ideal if the instructional goal is analyzing how authors use allusion and convention to build arguments. However, that same text may not be a good fit if the instructional goal is content comprehension. ## Evaluator release history | Date | Changes | | --------------- | -------------------- | | August 27, 2026 | Minor prompt updates | | June 24, 2026 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Sentence Structure Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/sentence-structure Analyze sentence complexity in informational texts, including clause ratios and words per sentence, and get a grade-level complexity rating via LLM. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Sentence Structure evaluator assesses the complexity of sentence structure in informational texts relative to a specified grade level: * Identifies sentence features in the text, including sentence type composition, average words per sentence, subordinate clause ratios, and concepts per sentence. * Assigns an overall complexity rating using an LLM, combined with statistical thresholds for sentence features. ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy). The evaluator must be run in two stages — combining them into a single step reduces accuracy. | | | | :-------------- | :----- | | **Model used** | GPT-4o | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/sentence-structure.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/sentence-structure/example_notebook.ipynb) ↗
Prompts ([`analysis-system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/sentence-structure/analysis-system.txt) ↗, [`analysis-user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/sentence-structure/analysis-user.txt) ↗, [`complexity-system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/sentence-structure/complexity-system.txt) ↗, and [`complexity-user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/sentence-structure/complexity-user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :--------------------------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
10 - 10,000 words (\< 1,200 words recommended) | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Complexity score** | Complexity score ("Slightly complex", "Moderately complex", "Very complex", or "Exceedingly complex")

See [Interpreting results](#interpreting-results) for grade-specific criteria | | **Reasoning** | Detailed, pedagogically appropriate reasoning explaining how the qualitative structure and quantitative sentence statistics combine to produce the chosen complexity level | ## Interpreting results ### Grade 3 | Complexity score | How to use | | :---------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Slightly complex** | Simple, straightforward language and sentence structures

Meets 2+ of the following criteria:
  • Sentence type: Typically > 60% simple sentences
  • Sentence length: Typically \< 12 average words per sentence
  • Subordination: Typically \< 25% of sentences have subordinate clauses
| | **Moderately complex** | Mix of simple and more complex sentences:
  • Sentence type: Typically 40 - 60% simple sentences
  • Sentence length: Typically 12 - 16 average words per sentence
  • Subordination: Typically 25 - 45% of sentences have subordinate clauses
| | **Very complex** | More elaborate sentences with multiple clauses and ideas:
  • Sentence type: Typically \< 40% simple sentences
  • Sentence length: Typically 16 - 19 average words per sentence
  • Subordination: Typically > 45% of sentences have subordinate clauses
| | **Exceedingly complex** | Dense with very long, intricate sentences and high subordination

Meets 2+ of the following criteria, including 1+ from "Structural density":

**Structural density**
  • Subordination: Typically > 50% of sentences have subordinate clauses
  • Multiple subordination: Typically > 12% of sentences have 1+ subordinate clause
  • Syntactic complexity: Typically > 15% compound-complex sentences


**Length**
  • Sentence length: Typically > 19 average words per sentence
  • High concentration of very long sentences: Typically > 15% of sentences have 30+ words
| ### Grade 4 | Complexity score | How to use | | :---------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Slightly complex** | Simple, straightforward language and sentence structures

Meets 2+ of the following criteria:
  • Sentence type: Typically > 55% simple sentences
  • Sentence length: Typically \< 13 average words per sentence
  • Subordination: Typically \< 30% of sentences have subordinate clauses
| | **Moderately complex** | Mix of simple and more complex sentences:
  • Sentence type: Typically 40 - 55% simple sentences
  • Sentence length: Typically 13 - 17 average words per sentence
  • Subordination: Typically 30 - 50% of sentences have subordinate clauses
| | **Very complex** | More elaborate sentences with multiple clauses and ideas:
  • Sentence type: Typically \< 40% simple sentences
  • Sentence length: Typically 17 - 22 average words per sentence
  • Subordination: Typically > 50% of sentences have subordinate clauses
  • Multiple subordination: Typically > 8% of sentences have 1+ subordinate clause
| | **Exceedingly complex** | Dense with very long, intricate sentences and high subordination

Meets 2+ of the following criteria, including 1+ from "Structural density":

**Structural density**
  • Subordination: Typically > 60% of sentences have subordinate clauses
  • Multiple subordination: Typically > 15% of sentences have 1+ subordinate clause
  • Syntactic complexity: Typically > 20% compound-complex sentences


**Length**
  • Sentence length: Typically > 22 average words per sentence
  • High concentration of very long sentences: Typically > 15% of sentences have 30+ words
| ### Grades 5-12 | Complexity score | How to use | | :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Slightly complex** | >= 50% simple sentences

**Exception:** Moderately Complex if >= 50% simple sentences AND >= 20% compound sentences

**Important:** NEVER includes advanced complex sentences | | **Moderately complex** | Primarily simple and compound sentences, with some complex constructions; can take on any distribution of sentence types as long as there aren't > 2 advanced complex sentences and as long as there aren't so many simple sentences that the text becomes Slightly Complex.

May contain many simple sentences, compound sentences, and/or basic complex sentences, as well as 1 - 2 advanced complex sentences. | | **Very complex** | 3+ advanced complex sentences

**Exception:** Exceedingly Complex if >= 65% advanced complex sentences | | **Exceedingly complex** | >= 65% advanced complex sentences | ## Evaluator release history | Date | Changed | | ------------------ | -------------------- | | August 27, 2026 | Minor prompt updates | | February 18, 2026 | Added grades 5-12 | | September 23, 2025 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Vocabulary Complexity Source: https://docs.learningcommons.org/evaluators/student-facing-text-evaluators/vocabulary-complexity Identify Tier 2, Tier 3, and archaic words in a text and score vocabulary complexity against grade-level background knowledge with this evaluator. [Evaluator last updated August 27, 2026.](#evaluator-release-history) ## Overview The Vocabulary Complexity evaluator gives developers fine-grained vocabulary insights that help ensure texts use words that align with grade-level expectations and support growth in academic language: * Estimates the background knowledge that a student at the target grade level is likely to have * Identifies complex words in the text ([Tier 2](/evaluators/understanding-evaluators/core-concepts#tier-2), [Tier 3](/evaluators/understanding-evaluators/core-concepts#tier-3), [archaic](/evaluators/understanding-evaluators/core-concepts#archaic), etc.) * Evaluates overall vocabulary complexity relative to the background knowledge estimate ## At a glance | | | | :------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Inputs** | Informational text to evaluate and grade level | | **Supported grades** | 3–12 | | **Rubric** | [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗'s [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | The evaluator was built and validated using the model and temperature below (other configurations will produce different results and may have lower accuracy): | | | | :-------------- | :---------------------------------------------------------------------------------- | | **Model used** | GPT-4o (Step 1); Gemini-2.5-pro (Step 2, Grades 3–4); GPT-4.1 (Step 2, Grades 5–12) | | **Temperature** | 0 | ## Getting started Follow the [Quickstart](/evaluators/getting-started/quickstart) to start using this evaluator: | Access method | | | :------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Evaluators playground** | [View in Platform](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | | **SDK** | [Python](https://github.com/learning-commons-org/evaluators/blob/main/sdks/python/src/learning_commons_evaluators/evaluators/vocabulary.py) ↗ and [TypeScript](https://github.com/learning-commons-org/evaluators/blob/main/sdks/typescript/src/evaluators/student-facing-text/ela-reading/vocabulary-complexity.ts) ↗ | | **GitHub** | [Python notebook](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/vocabulary-complexity/example_notebook.ipynb) ↗
Prompts ([`grades-3-4-system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/vocabulary-complexity/grades-3-4-system.txt) ↗, [`grades-3-4-user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/vocabulary-complexity/grades-3-4-user.txt) ↗, [`other-grades-system.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/vocabulary-complexity/other-grades-system.txt) ↗, and [`other-grades-user.txt`](https://github.com/learning-commons-org/evaluators/blob/main/evals/student-facing-text/ela-reading/vocabulary-complexity/other-grades-user.txt) ↗) | ## Inputs | Input | Description | Required | | :-------------- | :---------------------------------------------------------------- | :------- | | **Text** | Informational text to evaluate
Optimal length: 130-205 words | Yes | | **Grade level** | Target student grade level | Yes | ## Output | Field | Description | | :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Tier 2 words** | [Tier 2](/evaluators/understanding-evaluators/core-concepts#tier-2) words in the text — words commonly used in academic settings, more complex than colloquial or everyday language, often with multiple meanings | | **Tier 3 words** | [Tier 3](/evaluators/understanding-evaluators/core-concepts#tier-3) words in the text — overly academic or domain-specific words | | **Archaic words** | [Archaic](/evaluators/understanding-evaluators/core-concepts#archaic) words in the text — common words used in an archaic way, not commonly used in modern conversational language | | **Other complex words** | All other words that can increase complexity of the text (e.g., idioms, unfamiliar proper nouns that function as vocabulary) | | **Complexity score** |
  • Slightly complex: Uses everyday, familiar vocabulary with few academic or domain-specific terms.
    • Almost entirely contemporary and conversational
    • Very low proportion of complex words (archaic, subject-specific, academic)
    • Easy to understand and does not impede comprehension of the bulk of the text (1-2 quick pauses for processing by the student may occur)
  • Moderately complex: Includes a mix of familiar and academic vocabulary, with some Tier 2 or Tier 3 terms that may require support.
    • Mostly contemporary and conversational
    • Low proportion of complex words (archaic, subject-specific, academic)
    • Generally allows students to comprehend the bulk of the text with little difficulty, though there may be occasional pauses for clarification (several quick pauses or occasional prolonged pauses may occur)
  • Very complex: Relies heavily on Tier 2 and Tier 3 vocabulary with limited contextual scaffolding.
    • Often unfamiliar, archaic, subject-specific, and/or overly academic
    • Often presents challenges that may slow down comprehension, but does not completely block the comprehension of the bulk of the text
  • Exceedingly complex: Uses dense academic and domain-specific vocabulary that is likely to be inaccessible without significant support.
    • Mostly unfamiliar, archaic, subject-specific, and/or overly academic
    • May be ambiguous or purposefully misleading
    • Makes comprehension of the bulk of the text very challenging and requires careful effort to interpret
| | **Reasoning** | Detailed explanation of the rating. Grades 3-4 reference density and cumulative effect, contextual scaffolding, abstract vs. concrete vocabulary, conceptual load, and the provided student background knowledge; other grades reference the annotation guide and rubric | ## Evaluator release history | Date | Changed | | ------------------ | -------------------- | | August 27, 2026 | Minor prompt updates | | September 23, 2025 | First release | ## Related topics Explore other evaluators that assess qualitative text complexity. Explore the expert-annotated benchmark behind literacy evaluators. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Core concepts Source: https://docs.learningcommons.org/evaluators/understanding-evaluators/core-concepts Learn the fundamental concepts of evaluators including what they are, how they work, and key terminology for using evaluators effectively. ## How evaluators are designed | Concept | Definition | | :--------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Evaluator](#evaluator)

| Evaluates AI-generated content by focusing on one [dimension](#dimension) of a [rubric](#rubric)
**Example:** The [Vocabulary Complexity evaluator](/evaluators/student-facing-text-evaluators/vocabulary-complexity) focuses on one dimension (vocabulary) of the [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ | |

[Dimension](#dimension)

| Describes one specific attribute or criterion of AI-generated content
**Example:** Evaluators can look at Vocabulary, Sentence Structure, and other dimensions of the text when evaluating its complexity. | |

[Rubric](#rubric)

| Provides a framework for evaluating a concept (e.g., Qualitative Text Complexity) through multiple [dimensions](#dimension)

Illustration showing a sample rubric structure used by evaluators.
**Example:** The [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗ looks at dimensions like Vocabulary and Sentence Structure to make a judgment on a text's complexity. | |

[Evaluator family](#evaluator-family)

| Collection of evaluators that evaluate [dimensions](#dimension) of one [rubric](#rubric)**Example:** The [Student-Facing Text evaluator family](/evaluators/student-facing-text-evaluators/introduction) contains multiple evaluators that each assess one dimension of the [Qualitative Text Complexity Rubric for Informational Text](https://learnwithsap.b-cdn.net/app/uploads/2026/04/Qualitative-Text-Complexity-Rubric-Informational.pdf) ↗. | ## How outputs are validated | Concept | Definition | | :----------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Evaluator dataset](#evaluator-dataset)

| [Dataset](/evaluators/dataset/introduction) rigorously annotated by human domain experts according to a [rubric](#rubric)

These annotated datasets train and inform our "LLM as a judge" assessments, making our evaluators more accurate with every iteration.
**Example:** We partnered with literacy experts to create the [Student-Facing Text dataset](/evaluators/dataset/student-facing-text), which we also used to develop our [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction). | |

[LLM as a judge](#llm-as-a-judge)

| Evaluation method that automates human-like reasoning at scale

Learning Commons uses this evaluation method to develop our evaluators. We prompt LLMs to use our expert-annotated [evaluator datasets](#evaluator-dataset) to validate our evaluators' outputs. | |

[Baseline prompt](#baseline-prompt)

| Simulates what an edtech developer might construct quickly without expert-annotated datasets, structured rubric alignment, or prompt optimization

Learning Commons uses baseline prompts to measure how much our expert-annotated [evaluator datasets](/evaluators/dataset/introduction) improve our evaluators' performance. | |

[Accuracy](#accuracy)

| Degree to which an evaluator aligns with our [evaluator datasets](/evaluators/dataset/introduction), or how often an evaluator agrees with a human expert

Learn more about [How accuracy is measured](#how-accuracy-is-measured) and our recommended [use cases](#use-cases). | ### For Student-Facing Text evaluators | Concept | Definition | | :--------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |

[Tier 2](#tier-2)

| General academic words that appear across subject areas and are more common in writing than speech (e.g., vary, factors, determine)

Students may have encountered these words, but are unlikely to have fully mastered them at lower grade levels. | |

[Tier 3](#tier-3)

| Domain- or subject-specific words that are rare outside a particular field (e.g., precipitation, latitude, equator)

Students are unlikely to know these words without prior instruction in that subject. | |

[Archaic](#archaic)

| Words that are outdated or no longer common in contemporary writing

Students may be unfamiliar with these words, regardless of grade level. | ## How accuracy is measured An evaluator's accuracy is calculated on every evaluation run per input (**single-run accuracy**). Because LLM outputs are probabilistic and inherently non-deterministic, accuracy results may vary across evaluation runs (even with the same inputs). To reduce your evaluators' variability and increase their reliability in production: 1. Run the evaluator multiple times on the same input 2. Treat each output as a vote 3. Select the majority result (for example, 3 runs with majority selection) ### Metrics Not all evaluators will return all accuracy metrics. | Accuracy metric | Definition | | :--------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Overall accuracy](#overall-accuracy)

| Percentage of predictions that exactly match the expert-annotated [evaluator dataset](#evaluator-dataset) Some disagreements between our evaluators and human experts are expected, especially in qualitative domains and borderline cases. | |

[Expert agreement rate](#expert-agreement-rate)

| Percentage of reviewed cases where experts agree with evaluator output | |

[Reasoning quality score](#reasoning-quality-score)

| Expert rating of explanation quality (often on a numeric scale) | |

[Baseline comparison accuracy](#baseline-comparison-accuracy)

| Performance relative to a minimal [baseline prompt](#baseline-prompt) | ### Use cases Use accuracy metrics to inform implementation decisions, not replace human judgment. | Recommended | Not recommended | | :----------------------------------------------- | :-------------------------------------------------------- | | Estimate expected agreement with expert judgment | Fully automate high-stakes decisions | | Set appropriate thresholds for downstream logic | Assume consistent performance outside the validated scope | | | Replace domain expertise where interpretation is critical | ## Related topics See how expert-annotated datasets ground evaluator accuracy. Explore evaluators that assess qualitative text complexity. Explore evaluators that assess the quality of coaching feedback. Explore evaluators that assess content alignment to academic standards. # Introduction Source: https://docs.learningcommons.org/evaluators/understanding-evaluators/introduction Learn what evaluators are and how they help measure the quality of AI-generated educational materials through pedagogical alignment assessment. Evaluator notebooks, prompts, and SDKs live in the [`evaluators`](https://github.com/learning-commons-org/evaluators) ↗ GitHub repository. ## What evaluators do Evaluators measure the quality of AI-generated educational content by assessing specific dimensions of text and identifying areas for improvement. Evaluators help edtech developers reliably assess their LLM outputs and build evidence-based tools that reinforce student learning and whole child development. | Evaluator family | Description | | :---------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------- | | [Student-Facing Text evaluators](/evaluators/student-facing-text-evaluators/introduction) | Assess the qualitative text complexity of a passage, often for a particular grade level | | [Feedback evaluators](/evaluators/feedback-evaluators/introduction) | Assess the quality of feedback on a student's response to a task goal | | [Academic Standards evaluators](/evaluators/academic-standards-evaluators/introduction) | Assess the alignment of educational content to standards | Explore [Use cases](/evaluators/understanding-evaluators/use-cases) for evaluators while testing, refining, or scaling AI-generated content. ## How to access evaluators | Access method | When to use | | :------------------------------------------------------------------------------------ | :-------------------------------------------------- | | [Evaluators playground](/evaluators/getting-started/quickstart#evaluators-playground) | For a quick demo of how evaluators work | | [SDK](/evaluators/getting-started/quickstart#sdk) | To integrate into your TypeScript or Python project | | [Python notebook](/evaluators/getting-started/quickstart#python-notebooks) | For quick prototyping | ## Our approach Learning Commons collaborates closely with pedagogical experts to define, test, and build our evaluators. We follow a research-informed process to develop evaluators that are firmly anchored in learning science: Diagram showing the AIDT process for designing and validating evaluators * We build alongside experts in learning science and rubric development (e.g., [Student Achievement Partners (SAP)](https://learnwithsap.org/) ↗, [CAST](https://www.cast.org/) ↗, and [Achievement Network (ANet)](https://www.achievementnetwork.org/) ↗). * We translate expert insight into ground-truth datasets that reflect real teaching and learning principles. * We develop, validate, and ship software that evaluates text the way an expert would. ## Related topics Explore product, model selection, runtime, and trust workflows for evaluators. Learn how evaluators, dimensions, rubrics, and accuracy work together. Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # Use cases Source: https://docs.learningcommons.org/evaluators/understanding-evaluators/use-cases Common evaluator use cases: optimize product features, select models, check outputs at runtime, monitor consistency, and build trust with users. These are several common ways that edtech teams use evaluators when building, testing, and operating AI features. Multiple use cases for evaluators at different stages of product development | Use case | Examples | Implementation | | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Optimize your product or feature | You are building a vocabulary-focused feature – you want higher vocabulary difficulty and simpler sentence structure.

You are creating read-aloud support and want to deprioritize vocabulary complexity. | Set targets for vocabulary and sentence structure against grade level appropriateness. Run the [Sentence Structure Evaluator](/evaluators/student-facing-text-evaluators/sentence-structure) and [Vocabulary Complexity Evaluator](/evaluators/student-facing-text-evaluators/vocabulary-complexity) on your LLM outputs to confirm that they stay in acceptable ranges. | | Select the right model | You need to compare new models on quality, speed, and cost before switching. | Create a *gold set* with expected scores for key parameters (e.g., grade level, topic, text type). Use evaluators as a standardized benchmark to monitor drift from your baseline. | | Check your output at runtime | Your AI outputs may not always meet all your criteria (i.e., grade level appropriateness for K-3). | You can auto-optimize your AI-generated output or let users evaluate the output themselves. | | Monitor output consistency | Your AI output starts to vary unexpectedly after model drift or small system updates. | Run regular regression tests on your LLM outputs and compare scores over time to ensure stable behavior. | | Build trust with users | Districts and educators ask for evidence that your AI-generated content is high-quality and aligned with learning principles. | Share your evaluation process and results so stakeholders can see the rigor behind your system and trust that your outputs remain consistent and research-aligned. | ## Related topics Run an evaluator in the Evaluators playground, a Python notebook, or with the SDK. # IM® v.360 Source: https://docs.learningcommons.org/knowledge-graph/datasets/curriculum/im-v360 Reference for IM® v.360 in Knowledge Graph: courses, lessons, activities, and assessments aligned to the K-12 curriculum ontology and math standards. [Dataset last updated June 18, 2026.](#dataset-release-history)
Mixed
Some downloads in this dataset require approval to access. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for more details.
## Overview The IM® v.360 dataset uses Curriculum [entities](/knowledge-graph/schema-reference/curriculum#entities) and [relationships](/knowledge-graph/schema-reference/curriculum#relationships). The IM® v.360 dataset represents IM® v.360 scope and sequence for K–12 Math, structured according to Learning Commons' K-12 curriculum ontology. | | | | :----------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [IM® v.360](https://illustrativemathematics.org/) ↗ | | **Supported grades** | K-12 | | **Includes** |
  • **Scope and Sequence** Open
  • **Instructional Materials** Gated
  • **Assessment Materials** Gated
| | **Dataset dependencies** | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - Math standards | | **REST API endpoints** | [Curriculum](/api-reference/curriculum/courses-in-a-curriculum) | ## Use cases | Use case | Examples | | :---------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Align content to official curriculum scope and sequence** |
  • Query IM® v.360 units and lessons aligned to the 2.NBT.B.5 standard
  • Generate lesson plans and parent-facing activities grounded in the IM® v.360 curriculum
  • Use the dependency map to sequence units and lessons
| | **Map student performance data to standards** |
  • Connect assessment results to the standards addressed in certain lessons or activities
  • Identify student gaps by unit or lesson
| ## Schema The data models courses, instructional groupings, and aligned standards with the following entities and relationships: | | | | :------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: Curriculum entities (Course, LessonGrouping, Lesson, Activity, Assessment, Material) and relationships (hasEducationalAlignment, usesRoutine, hasDependency, and references) | | [**Entities**](/knowledge-graph/schema-reference/curriculum#entities) |
  • [`Course`](/knowledge-graph/schema-reference/curriculum#course)
    • Root node for a grade-level course (e.g. Illustrative Mathematics® Grade 2)
  • [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping)
    • Unit, module, or section (e.g. Unit 3: Adding and Subtracting within 100)
  • [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson)
    • Single instructional session (e.g. Lesson 1: How do we count collections?)
  • [`Activity`](/knowledge-graph/schema-reference/curriculum#activity)
    • Instructional activity within a lesson
  • [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment)
    • Formative or summative assessment
  • [`Material`](/knowledge-graph/schema-reference/curriculum#material)
    • Instructional materials (e.g. student-facing content)
  • [`ClassroomMaterial`](/knowledge-graph/schema-reference/curriculum#classroommaterial)
    • Teacher-facing materials such as handouts or manipulatives
  • [`GlossaryTerm`](/knowledge-graph/schema-reference/curriculum#glossaryterm)
    • Vocabulary term referenced by lessons
  • [`InstructionalRoutine`](/knowledge-graph/schema-reference/curriculum#instructionalroutine)
    • Structured teaching strategy (e.g. Number Talks)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (defined in [Standards](/knowledge-graph/schema-reference/standards#entities))
    • Standard linked via hasEducationalAlignment (e.g. 2.NBT.B.5)
| | [**Relationships**](/knowledge-graph/schema-reference/curriculum#relationships) |
  • [`Course`](/knowledge-graph/schema-reference/curriculum#course) → [`hasPart`](/knowledge-graph/schema-reference/curriculum#haspart) → [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) (e.g. Grade 2 → Unit 3)
  • [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) → [`hasPart`](/knowledge-graph/schema-reference/curriculum#haspart) → [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson) (e.g. unit → lesson)
  • [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson) → [`hasPart`](/knowledge-graph/schema-reference/curriculum#haspart) → [`Activity`](/knowledge-graph/schema-reference/curriculum#activity) or [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment)
  • [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) → [`hasEducationalAlignment`](/knowledge-graph/schema-reference/curriculum#haseducationalalignment) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. unit → 2.NBT.B.5)
  • [`Activity`](/knowledge-graph/schema-reference/curriculum#activity) → [`usesRoutine`](/knowledge-graph/schema-reference/curriculum#usesroutine) → [`InstructionalRoutine`](/knowledge-graph/schema-reference/curriculum#instructionalroutine) (e.g. activity → Number Talks)
  • [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) → [`hasDependency`](/knowledge-graph/schema-reference/curriculum#hasdependency) → [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) (prerequisite units)
  • [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson) → [`references`](/knowledge-graph/schema-reference/curriculum#references) → [`GlossaryTerm`](/knowledge-graph/schema-reference/curriculum#glossaryterm)
  • [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment) → [`mutuallyExclusiveWith`](/knowledge-graph/schema-reference/curriculum#mutuallyexclusivewith) → [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment) (equal alternatives)
| ## Dataset release history | Date | Changed | | ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | June 18, 2026 | Data quality improvements: trimmed whitespace, fixed `inLanguage` and `gradeLevel` fields, removed duplicate relationships, added missing `Material` entities, and updated `mutuallyExclusiveWith` links. | | March 26, 2026 | Added `publisherIdentifier` property containing Illustrative Mathematics's original content IDs. | | January 28, 2026 | First release of IM® v.360 scope and sequence under CC BY-4.0. | ## Related topics Review entities, relationships, and property definitions for Curriculum. Query courses, scope and sequence, lessons, and assessments via the REST API. # Learner Variability Navigator Source: https://docs.learningcommons.org/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator Explore the Learner Variability Navigator dataset from Digital Promise, which links student characteristics to instructional strategies for PK-12 learners. [Dataset last updated January 28, 2026.](#dataset-release-history)
Gated
All downloads in this dataset require approval to access. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for more details.
## Overview The Learner Variability Navigator dataset uses Instructional guidance [entities](/knowledge-graph/schema-reference/instructional-guidance#entities) and [relationships](/knowledge-graph/schema-reference/instructional-guidance#relationships). The Learner Variability Navigator dataset takes individual students' characteristics into account when recommending instructional practices to help them reach their learning goals. | | | | :----------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Learner Variability Tool from Digital Promise®](https://lvp.digitalpromiseglobal.org/) ↗ | | **Supported grades** | PK-12

Includes the following [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel)s:
  • Math PK-2
  • Math 3-6
  • Math 7-10
  • Literacy PK-3
  • Literacy 4-6
  • Literacy 7-12
  • Portrait of a Learner PK-3
  • Portrait of a Learner 4-8
  • Portrait of a Learner 9-12
| | **Includes** |
  • **Math models** Gated
  • **Literacy models** Gated
| | **Dataset dependencies** | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - Math standards, ELA standards | | **REST API endpoints** | Not yet supported | ## Use cases | Use case | Examples | | :----------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Support diverse learners with research-backed strategies** |
  • Recommend a strategy like "Peer teaching" for learners with working memory challenges
  • Input an academic standard and your student's factors to get relevant instructional strategies
| ## Schema The data connects student context and learning goals to instructional strategies with the following entities and relationships: | | | | :------------------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Data model** | Data model diagram: Learner Variability Navigator entities—LearnerModel, Factor, Strategy—and their connections for linking student context and learning goals to instructional practices | | [**Entities**](/knowledge-graph/schema-reference/instructional-guidance#entities) |
  • [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel)
    • Grade- and subject-specific profile (e.g. Math 3–6)
  • [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor)
    • Research-backed element that influences learning (e.g. Working memory)
  • [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy)
    • Instructional practice that supports learning (e.g. Peer teaching)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (defined in [Standards](/knowledge-graph/schema-reference/standards#entities))
    • Standard linked via relevantToStandard (e.g. 6.EE.A.2)
| | [**Relationships**](/knowledge-graph/schema-reference/instructional-guidance#relationships) |
  • [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel) → [`hasFactor`](/knowledge-graph/schema-reference/instructional-guidance#hasfactor) → [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) (e.g. Math 3–6 → Working memory)
  • [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel) → [`hasStrategy`](/knowledge-graph/schema-reference/instructional-guidance#hasstrategy) → [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy) (e.g. Math 3–6 → Peer teaching)
  • [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) → [`interactsWithFactor`](/knowledge-graph/schema-reference/instructional-guidance#interactswithfactor) → [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) (e.g. Working memory ↔ Attention)
  • [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy) → [`targetsFactor`](/knowledge-graph/schema-reference/instructional-guidance#targetsfactor) → [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) (e.g. Peer teaching → Math communication)
  • [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) → [`relevantToStandard`](/knowledge-graph/schema-reference/instructional-guidance#relevanttostandard) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. Algebraic reasoning → 6.EE.A.2)
| ## Dataset release history | Date | Changed | | ---------------- | ------------------------------------------------------------------------------------- | | January 28, 2026 | Added `relevantToStandard` relationship linking Factors to Common Core ELA standards. | | December 8, 2025 | First release of Learner Variability Navigator data from Digital Promise. | ## Related topics Review entities, relationships, and property definitions for Instructional Practices. Connect learner factors to the standards they are relevant to. Pair instructional strategies with curriculum lessons and activities. # Introduction Source: https://docs.learningcommons.org/knowledge-graph/datasets/introduction Overview of Knowledge Graph datasets grouped into standards, learning components, learning progressions, curriculum, and instructional guidance. ## Overview Knowledge Graph data is grouped into 5 categories: * [**Standards**](/knowledge-graph/schema-reference/standards) - Official expectations for student learning across academic subjects and jurisdictions, plus durable skills and learner competencies * [**Learning components**](/knowledge-graph/schema-reference/learning-components) - Granular skills or concepts that break academic standards down into teachable parts * [**Learning progressions**](/knowledge-graph/schema-reference/learning-progressions) - Representations of how standards build towards and relate to each other * [**Curriculum**](/knowledge-graph/schema-reference/curriculum) - Standards-aligned lessons and assessments provided by a publisher * [**Instructional guidance**](/knowledge-graph/schema-reference/instructional-guidance) - Grade- and subject-specific learner profiles, research-backed factors, and instructional strategies Each category contains datasets that share a schema. Each dataset covers a specific educational domain and includes one or more file downloads. Browse and download dataset files from the [Dataset catalog](https://platform.learningcommons.org/dataset-catalog) ↗. ## Dataset coverage by category ### [Standards](/knowledge-graph/schema-reference/standards) | Dataset | Access type | Description | Coverage | | :--------------------------------------------------------------------------------------------------------- | :------------------ | :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) | Open | Official learning expectations across U.S. states and subjects | K-12 for all 50 U.S. states and Washington, D.C. for Math, ELA, Science, and Social Studies, plus WIDA English Language Development Standards | | [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) | Open | Similarity matches between state and CCSS standards | K-12 for Math and ELA in U.S. standards (where learning components alignment exists) | | [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) | Open | Collaboration, Communication, and Critical Thinking | 9–12 for Collaboration, Communication, and Critical Thinking | | [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) | Open | Durable-skill learner outcomes and competencies | 9–12 for 5 durable-skill learner outcomes | ### [Learning components](/knowledge-graph/schema-reference/learning-components) | Dataset | Access type | Description | Coverage | | :------------------------------------------------------------------------------------------------- | :------------------ | :----------------------------------------------------------------------- | :-------------------------------------------- | | [Math learning components](/knowledge-graph/datasets/learning-components/math-learning-components) | Open | Granular Math skills and concepts aligned to standards | K-12 for Common Core and 40+ state frameworks | | [ELA learning components](/knowledge-graph/datasets/learning-components/ela-learning-components) | Open | Granular ELA skills and concepts aligned to standards | K-2 for Common Core and 12 states | ### [Learning progressions](/knowledge-graph/schema-reference/learning-progressions) | Dataset | Access type | Description | Coverage | | :--------------------------------------------------------------------------------------- | :------------------ | :-------------------------------------------------------------- | :-------------------------------- | | [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) | Open | Prerequisite and successor relationships between math standards | K-12 for CCSSM | ### [Curriculum](/knowledge-graph/schema-reference/curriculum) | Dataset | Access type | Description | Coverage | | :-------------------------------------------------------- | :------------------- | :-------------------------------------------------------------------- | :-------- | | [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) | Mixed | Open scope and sequence; gated instructional and assessment materials | K–12 Math | ### [Instructional guidance](/knowledge-graph/schema-reference/instructional-guidance) | Dataset | Access type | Description | Coverage | | :-------------------------------------------------------------------------------------------------------------- | :------------------- | :----------------------------------------------------------------- | :---------------------- | | [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) | Gated | Learner factors and instructional strategies from Digital Promise® | PK–12 Math and Literacy | # ELA learning components Source: https://docs.learningcommons.org/knowledge-graph/datasets/learning-components/ela-learning-components Explore the ELA learning components dataset, which breaks English Language Arts standards into granular, teachable skills and concepts for grades K-2. [Dataset last updated June 18, 2026.](#dataset-release-history) ## Overview The ELA learning components dataset uses Learning Components [entities](/knowledge-graph/schema-reference/learning-components#entities) and [relationships](/knowledge-graph/schema-reference/learning-components#relationships). The ELA learning components dataset represents granular English Language Arts skills or individual concepts that operate at the instructional level – i.e., a lesson, an activity, or even a single question. It essentially breaks broad [standards](/knowledge-graph/schema-reference/standards) down into measurable, teachable parts. | | | | :----------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Learning Commons](https://learningcommons.org/) ↗
  • Includes Common Core State Standards for English Language Arts (CCSS ELA), Connecticut, Delaware, Illinois, Maryland, Michigan, Mississippi, Nevada, New Hampshire, Vermont, Washington, Washington, D.C., and Wyoming
| | **Supported grades** | K-2 | | **Includes** | **ELA** **learning components** Open | | **Dataset dependencies** | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - ELA standards | | **REST API endpoints** | [Learning components](/api-reference/learning-components/learning-components-for-a-standard) | ## Use cases | Use case | Examples | | :------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Target specific skills** |
  • Build lesson plans around granular skills like Identify the front cover of a book
  • Create activities that cater to specific concepts or skills, vs. a broader standard
| | **Tag educational content accurately** |
  • Tag questions, activities, and materials to the specific skills they assess
  • Improve search and recommendations by focusing on specific skills rather than broad standards
| | **Identify where students may need support on individual standards** |
  • Give each student a score for each Learning Component entity in the Knowledge Graph
  • Pinpoint the gaps in a student's skills for a given standard
| | **Underpin learning progressions** |
  • Plan a student's learning journey with skill-level granularity
  • Group students by the specific skills they have mastered or still need to learn
| Some standards do not have Learning Component alignments. College and Career Readiness Anchor standards along with non-leaf-node standards are not aligned to Learning Components. In addition, current Learning Components coverage is limited to standards from grades K–2. Additional grade bands will be added in future releases. ## Schema The data connects granular skills to academic standards with the following entities and relationships: | | | | :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: LearningComponent entities connected to StandardsFrameworkItem by the supports relationship | | [**Entities**](/knowledge-graph/schema-reference/learning-components#entities) |
  • [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)
    • Granular skill or concept (e.g. Identify the front cover of a book)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)
    • Standard that a Learning Component supports (e.g. RF.K.1.A)
| | [**Relationships**](/knowledge-graph/schema-reference/learning-components#relationships) |
  • [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) → [`supports`](/knowledge-graph/schema-reference/learning-components#supports) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. Identify the front cover of a book → RF.K.1.A)
| ## Dataset release history | Date | Changed | | ------------- | ------------------------------------------------------------------------------------------------------------------------------ | | June 18, 2026 | Updated license and attribution statement values for English Language Arts rows; removed duplicate Learning Components. | | May 27, 2026 | Added English Language Arts Learning Components (grades K–2) and alignments for 12 states; added optional `examples` property. | ## Roadmap We will be expanding English Language Arts support for more grade bands and state [standards frameworks](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-frameworks) in upcoming releases. ## Related topics Review entities, relationships, and property definitions for Learning Components. Explore Mathematics Learning Components coverage and use cases. Query learning components by ID, subject, or standard via the REST API. See the standards that Learning Components support and align to. # Math learning components Source: https://docs.learningcommons.org/knowledge-graph/datasets/learning-components/math-learning-components Explore the Math learning components dataset, which breaks math standards into granular skills and concepts you can use for content tagging and alignment. [Dataset last updated June 18, 2026.](#dataset-release-history) ## Overview The Math learning components dataset uses Learning Components [entities](/knowledge-graph/schema-reference/learning-components#entities) and [relationships](/knowledge-graph/schema-reference/learning-components#relationships). The Math learning components dataset represents granular mathematics skills or individual concepts that operate at the instructional level – i.e., a lesson, an activity, or even a single question. It essentially breaks broad [standards](/knowledge-graph/schema-reference/standards) down into measurable, teachable parts. | | | | :----------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Achievement Network](https://www.achievementnetwork.org/) ↗
  • Includes Common Core State Standards for Mathematics (CCSSM), Alabama, Arkansas, California, Colorado, Connecticut, Delaware, Florida, Georgia, Hawaii, Idaho, Illinois, Iowa, Kansas, Kentucky, Louisiana, Maine, Maryland, Massachusetts, Michigan, Mississippi, Missouri, Montana, Nevada, New Hampshire, New Jersey, New Mexico, New York, North Carolina, North Dakota, Ohio, Oregon, Pennsylvania, Rhode Island, South Dakota, Tennessee, Texas, Utah, Vermont, Washington, Washington, D.C., West Virginia, Wisconsin, and Wyoming
| | **Supported grades** | K-12 | | **Includes** | **Math learning components** Open | | **Dataset dependencies** | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - Math standards | | **REST API endpoints** | [Learning components](/api-reference/learning-components/learning-components-for-a-standard) | ## Use cases | Use case | Examples | | :------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Target specific skills** |
  • Build lesson plans around granular skills like Use place value to add two two-digit numbers
  • Create activities that cater to specific concepts or skills, vs. a broader standard
| | **Tag educational content accurately** |
  • Tag questions, activities, and materials to the specific skills they assess
  • Improve search and recommendations by focusing on specific skills rather than broad standards
| | **Identify where students may need support on individual standards** |
  • Give each student a score for each Learning Component entity in the Knowledge Graph
  • Pinpoint the gaps in a student's skills for a given standard
| | **Underpin learning progressions** |
  • Plan a student's learning journey with skill-level granularity
  • Group students by the specific skills they have mastered or still need to learn
| Some standards do not have Learning Component alignments. Categories like Standards for Mathematical Practice (SMPs), Pre-K, advanced math such as calculus, financial literacy in Texas, and certain state-specific groupings are intentionally excluded from Learning Component generation. ## Schema The data connects granular skills to academic standards with the following entities and relationships: | | | | :--------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: LearningComponent entities connected to StandardsFrameworkItem by the supports relationship | | [**Entities**](/knowledge-graph/schema-reference/learning-components#entities) |
  • [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)
    • Granular skill or concept (e.g. Use place value to add two two-digit numbers)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)
    • Standard that a Learning Component supports (e.g. 2.NBT.B.5)
| | [**Relationships**](/knowledge-graph/schema-reference/learning-components#relationships) |
  • [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) → [`supports`](/knowledge-graph/schema-reference/learning-components#supports) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. Use place value to add two two-digit numbers → 2.NBT.B.5)
| ## Dataset release history | Date | Changed | | ------------------ | ------------------------------------- | | June 18, 2026 | Removed duplicate learning components | | September 23, 2025 | First release | ## Roadmap We will be expanding Mathematics support for more state [standards frameworks](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-frameworks) in upcoming releases. ## Related topics Review entities, relationships, and property definitions for Learning Components. Explore English Language Arts Learning Components coverage and use cases. Use Learning Components to analyze cross-state standards alignment. Query learning components by ID, subject, or standard via the REST API. See the standards that Learning Components support and align to. # Math Coherence Map Source: https://docs.learningcommons.org/knowledge-graph/datasets/learning-progressions/math-coherence-map Explore the Math Coherence Map dataset from Student Achievement Partners, which links Common Core math standards through K-12 prerequisite learning paths. [Dataset last updated September 23, 2025.](#dataset-release-history) ## Overview The Math Coherence Map dataset represents how students traverse learning paths to develop understanding over time. It includes both directional progressions and non-sequential conceptual links. | | | | :----------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Student Achievement Partners'](https://achievethecore.org/) ↗ [Coherence Map for Common Core State Standards for Mathematics](https://tools.achievethecore.org/coherence-map/) ↗ | | **Supported grades** | K-12 | | **Includes** | **Math Coherence Map** Open | | **Dataset dependencies** | [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - Math standards | | **REST API endpoints** |
  • [Prerequisites for a standard](/api-reference/academic-standards/prerequisites-for-a-standard)
  • [Standards a standard builds towards](/api-reference/academic-standards/standards-a-standard-builds-towards)
  • [Related standards for a standard](/api-reference/academic-standards/related-standards-for-a-standard)
| ## Use cases | Use case | Examples | | :------------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Trace prerequisite and successor academic standards** |
  • Query prerequisites for the 4.NBT.B.5 standard
  • Find all the standards that the 3.OA.A.1 standard builds towards
| | **Build coherent instructional sequences and learning paths** |
  • Ensure students have mastered prerequisite skills before introducing new ones
  • Explore both directional (prerequisite and successor) and non-sequential conceptual links
| ## Schema The data models how student understanding develops over time with the following entities and relationships: | | | | :----------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: StandardsFrameworkItem nodes connected by buildsTowards and relatesTo (Coherence Map learning progressions) | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (defined in [Standards](/knowledge-graph/schema-reference/standards#entities))
    • Standard from Common Core Math (e.g. 3.OA.A.1 or 4.NBT.B.5)
| | [**Relationships**](/knowledge-graph/schema-reference/learning-progressions#relationships) |
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) → [`buildsTowards`](/knowledge-graph/schema-reference/learning-progressions#buildstowards) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. 3.OA.A.1 → 4.NBT.B.5)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) → [`relatesTo`](/knowledge-graph/schema-reference/learning-progressions#relatesto) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. 3.NF.A.1 ↔ 3.NF.A.2)
| ## Dataset release history | Date | Changed | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------- | | September 23, 2025 | First release based on the [Student Achievement Partners Coherence Map](https://tools.achievethecore.org/coherence-map/) ↗ for CCSSM. | ## Related topics Review entities, relationships, and property definitions for Learning Progressions. Use progressions to find prerequisites and generate practice content. # Carnegie Skills Progressions Source: https://docs.learningcommons.org/knowledge-graph/datasets/standards/carnegie-skills-progressions Explore the Carnegie Skills Progressions dataset covering collaboration, communication, and critical thinking skills across four levels for grades 9-12. [Dataset last updated August 12, 2026.](#dataset-release-history) ## Overview The Carnegie Skills Progressions dataset represents a research-grounded framework for durable, employer-recognized skills. It describes how each skill develops across 4 progression levels in high school. | | | | :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Carnegie Foundation for the Advancement of Teaching](https://www.carnegiefoundation.org/) ↗ and [ETS](https://www.ets.org/) ↗'s *Skills Progressions, Vol. 1* | | **Supported grades** | 9–12 | | **Includes** | **Carnegie Skills Progressions** Open
  • Collaboration
  • Communication
  • Critical Thinking
| | **Dataset dependencies** | None | | **REST API endpoints** | [Durable skills](/api-reference/durable-skills/durable-skills-frameworks) | In future releases, the Carnegie Skills Progressions dataset will be expanded to include: * **Additional skills** that have been finalized in later Carnegie volumes ## Use cases | Use case | Examples | | :------------------------------------------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Build rubrics and assess student work** |
  • Score student work directly against the four-level progressions (Exploring → Analyzing → Integrating → Extending)
  • Skip hand-coding a rubric from a PDF
| | **Tag AI-generated content** |
  • Label or align AI-generated content and activities to specific durable skills and indicators
| | **Support project-based and career-connected learning** |
  • Attach employer-recognized, cross-jurisdiction language for Collaboration, Communication, and Critical Thinking to projects and work-based experiences
| | **Localize a Portrait of a Graduate** |
  • Map a district's Portrait of a Graduate to Carnegie's multi-state language to present durable skills goals in terms a wider range of districts will accept
| | **Query durable skills alongside academic standards** |
  • Treat durable skills as a queryable dimension alongside academic standards, using a shared data model to build against more than one framework at once
| ## Schema The data uses [standards](/knowledge-graph/schema-reference/standards) entities to represent **Skills**, **Subskills**, **Indicators**, **Indicator Items**, and **Progression Levels** in a 5-level tree: | | | | :----------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Carnegie Skills Progressions data model diagram | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) (e.g., *Carnegie Skills Progressions, Vol. 1*)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) with 5 `statementType`s:
    • **Skill** — i.e., Collaboration, Communication, or Critical Thinking
    • **Subskill** — Named capability within a skill
    • **Indicator** — Thematic, observable statement within a subskill
    • **Indicator Item** — Concrete, assessable item under an indicator (e.g. *1.1A*)
    • **Progression Level** — i.e., Exploring, Analyzing, Integrating, or Extending
| | [**Relationships**](/knowledge-graph/schema-reference/standards#relationships) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → **Skill** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Skill** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Subskill** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Subskill** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Indicator** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Indicator** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Indicator Item** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Indicator Item** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Progression Level** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
| Skills and Progression Levels carry a `name`. Subskills, Indicators, and Indicator Items have `name` set to null and `description` set to include the statement. ## Dataset release history | Date | Changed | | --------------- | ---------------------------------------------------------------------------- | | August 12, 2026 | First release for Collaboration, Communication, and Critical Thinking Skills | ## Related topics Review entities, relationships, and property definitions for the shared `StandardsFramework` and `StandardsFrameworkItem` model. Query durable skills through the REST API — list frameworks, browse a framework's skills, and search by keyword or statement code. # English Language Development Standards Framework Source: https://docs.learningcommons.org/knowledge-graph/datasets/standards/english-language-development-standards-framework Reference for the WIDA English Language Development Standards dataset in Knowledge Graph, covering language expectations for multilingual learners. [Dataset last updated September 23, 2025.](#dataset-release-history) ## Overview The English Language Development Standards Framework dataset uses Standards [entities](/knowledge-graph/schema-reference/standards#entities) and [relationships](/knowledge-graph/schema-reference/standards#relationships). The English Language Development Standards Framework dataset represents [WIDA](https://wida.wisc.edu/) ↗'s official expectations for language development for multilingual learners. | | | | :----------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [WIDA](https://wida.wisc.edu/) ↗ via [Common Good Learning Tools](https://rosetta.commongoodlt.com/) ↗'s [CASE data](https://www.imsglobal.org/activity/case) ↗ | | **Supported grades** | K-12 | | **Includes** | **English Language Development Standards Framework** Open | | **Dataset dependencies** | None | | **REST API endpoints** | [Academic standards](/api-reference/academic-standards/standards-frameworks) | ## Use cases | Use case | Examples | | :--------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Align instructional content to official learning goals** |
  • Use ELD standards as context to create AI-generated lesson plans for multilingual learners
  • Integrate ELD standards data with your CMS for easy content tagging
| | **Power richer analytics** |
  • Aggregate performance or coverage data by ELD standard
  • Reduce maintenance burden on internal standards infrastructure
| | **Query ELD alongside academic standards** |
  • Treat English Language Development as a queryable dimension alongside [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards), using a shared data model to build against more than one framework at once
| ## Schema The data represents [standards frameworks](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-frameworks), [standards groups](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-groups), and individual [standards](/knowledge-graph/understanding-knowledge-graph/core-concepts#academic-standard) as a tree with the following entities and relationships: | | | | :----------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: StandardsFramework and StandardsFrameworkItem entities linked by hasChild | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework)
    • Root node for the framework
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (child node to [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework))
    • Top-level grouping (e.g. Language for Language Arts)
    • **Standard** within a grouping (e.g. ELD.LA.4-5.Narrate.Interpretive)
| | [**Relationships**](/knowledge-graph/schema-reference/standards#relationships) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. WIDA ELD framework → its top-level standards)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. standard → language expectation)
| ## Dataset release history | Date | Changed | | ------------------ | ----------------------------------------------------------------------- | | September 23, 2025 | First release from [CASE Network 2](https://casenetwork.1edtech.org/) ↗ | ## Related topics Review entities, relationships, and property definitions for Academic Standards. Query standards by ID, search by statement code, and retrieve related content via the REST API. Discover available frameworks by jurisdiction, subject, and adoption status. # U.S. academic standards Source: https://docs.learningcommons.org/knowledge-graph/datasets/standards/us-academic-standards Explore the U.S. academic standards dataset with K-12 math, ELA, science, and social studies standards from all 50 states, sourced from CASE framework data. [Dataset last updated August 27, 2026.](#dataset-release-history) ## Overview The U.S. academic standards dataset uses Standards [entities](/knowledge-graph/schema-reference/standards#entities) and [relationships](/knowledge-graph/schema-reference/standards#relationships). The U.S. academic standards dataset represents the official expectations for student learning across academic subjects and jurisdictions. | | | | :----------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Common Good Learning Tools](https://rosetta.commongoodlt.com/) ↗'s [CASE data](https://www.imsglobal.org/activity/case) ↗ for all 50 U.S. states | | **Supported grades** | K-12 | | **Includes** |
  • **Math standards** Open
  • **ELA** **standards** Open
  • **Social Studies standards** Open
  • **Science standards** Open
| | **Dataset dependencies** | None | | **REST API endpoints** | [Academic standards](/api-reference/academic-standards/standards-frameworks) | When a state replaces a standards framework, the previous version still remains in the Knowledge Graph for comprehensive querying. | To access | Directions | | :------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Current frameworks | Look for standards frameworks with `isCurrent=true`. | | Standards for current frameworks | First find a current framework to see its related standards.

Filtering on jurisdiction and academic subject alone is NOT sufficient to get the most current standards or to disambiguate between standards belonging to different frameworks. | ## Use cases | Use case | Examples | | :--------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Compare standards across states** |
  • Populate a standards menu across all 50 states
  • Compare how the same concept is framed or taught in different jurisdictions
| | **Align instructional content to official learning goals** |
  • Use standards as context to create AI-generated lesson plans
  • Integrate standards data with your CMS for easy content tagging
| | **Power richer analytics** |
  • Aggregate performance or coverage data by standard across all the states you serve
  • Reduce maintenance burden on internal standards infrastructure
| | **Query standards without state-specific naming quirks** |
  • Query by jurisdiction, subject, and grade without learning each state's domain or cluster labels
  • Traverse [standards frameworks](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-frameworks) → [standards groups](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-groups) → individual [academic standards](/knowledge-graph/understanding-knowledge-graph/core-concepts#academic-standard) with normalized structure
| ## Schema The data represents [standards frameworks](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-frameworks), [standards groups](/knowledge-graph/understanding-knowledge-graph/core-concepts#standards-groups), and individual [standards](/knowledge-graph/understanding-knowledge-graph/core-concepts#academic-standard) as a tree with the following entities and relationships: | | | | :----------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Data model diagram: StandardsFramework and StandardsFrameworkItem entities linked by hasChild | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework)
    • Root node for a jurisdiction’s standards (e.g. New York State Mathematics Learning Standards)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (child node to [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework))
    • Top-level grouping like a **Domain** or **Cluster** (e.g. Operations and Algebraic Thinking or Number & Operations—Fractions)
    • **Standard** within a domain or cluster (e.g. 3.NF.A.1)
| | [**Relationships**](/knowledge-graph/schema-reference/standards#relationships) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. New York Math framework → its top-level domains)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (e.g. domain → cluster, or cluster → standard)
| ## Dataset release history | Date | Changed | | ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | August 27, 2026 | Added new frameworks; updated superseded frameworks to `isCurrent=false`; made updates and fixes to other standards frameworks | | August 12, 2026 | Updated standards from Common Good Learning Tools' [Rosetta](https://rosetta.commongoodlt.com/) ↗ data — refreshed frameworks and added new frameworks with `isCurrent=true` | | June 18, 2026 | Standards fixes for Montana Social Studies, New York Math, and Indiana Science | | October 30, 2025 | Added Washington, D.C. academic standards | | September 23, 2025 | First release from [CASE Network 2](https://casenetwork.1edtech.org/) ↗ for all 50 U.S. states | ## Related topics Review entities, relationships, and property definitions for Academic Standards. Explore another standards dataset with the WIDA English Language Development Standards Framework. Query frameworks and standards in a step-by-step tutorial. Query standards by ID, search by statement code, and retrieve related content via the REST API. Discover available frameworks by jurisdiction, subject, and adoption status. # U.S. academic standards crosswalks Source: https://docs.learningcommons.org/knowledge-graph/datasets/standards/us-academic-standards-crosswalks Explore the U.S. academic standards crosswalks dataset, which links state math standards to their closest Common Core matches by shared components. [Dataset last updated July 2, 2026.](#dataset-release-history) ## Overview The U.S. academic standards crosswalks dataset uses Standards [entities](/knowledge-graph/schema-reference/standards#entities) and [relationships](/knowledge-graph/schema-reference/standards#relationships). The U.S. academic standards crosswalks dataset connects state standards to their closest matching Common Core State Standards (CCSSM). It essentially measures how many [learning components](/knowledge-graph/schema-reference/learning-components) various [standards](/knowledge-graph/schema-reference/standards) have in common in order to calculate a similarity score. | | | | :----------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [Learning components](/knowledge-graph/schema-reference/learning-components) alignments to state and CCSSM mathematics standards

Crosswalks are derived from evidence-based matching—standards must share at least one Learning Component to generate an alignment. | | **Supported grades** | K-12 | | **Includes** |
  • **Math crosswalks** Open
  • **ELA** **crosswalks** Open
Standards crosswalks are not currently available for Social Studies, Science, or other academic subjects. To browse state standards for those subjects, reference the [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) dataset. | | **Dataset dependencies** |
  • [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - Math standards
  • [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) - ELA standards
| | **REST API endpoints** | [Standards crosswalks](/api-reference/standards-crosswalks/crosswalks-for-a-standard) | ## Use cases | Use case | Examples | | :-------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Map state standards to Common Core equivalents** |
  • Match a state standard like NY 3.NF.1 to its Common Core equivalent 3.NF.A.1
  • Evaluate state vs. Common Core standards alignment by comparing their shared [learning components](/knowledge-graph/datasets/learning-components/math-learning-components)
| | **Adapt CCSSM-aligned content to a specific state** |
  • Share the same CCSSM content across multiple states by automatically remapping the content to local standards
| ## Schema The data maps state standards to Common Core equivalents with the following entities and relationships: | | | | :------------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | Diagram: state mathematics standards linked to Common Core standards via hasStandardAlignment, with Jaccard similarity and shared Learning Components | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (state standard, defined in [Standards](/knowledge-graph/schema-reference/standards#entities))
    • Standard from a state framework (e.g. NY 3.NF.1)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (CCSS standard)
    • Matching Common Core standard (e.g. 3.NF.A.1)
| | [**Relationships**](/knowledge-graph/schema-reference/standards#hasstandardalignment) |
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (state) → [`hasStandardAlignment`](/knowledge-graph/schema-reference/standards#hasstandardalignment) → [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (CCSS) (e.g. NY 3.NF.1 → 3.NF.A.1)
| ## Dataset release history | Date | Changed | | ------------------ | ------------------------------------------------------------------------------------------------------------- | | July 2, 2026 | Restored Math Standards crosswalks between Texas and CCSS that were incorrectly removed in v1.9.0. | | June 18, 2026 | Removed duplicate Learning Components that were causing inaccurate Jaccard similarity scores. | | May 27, 2026 | Added English Language Arts Standards crosswalks alongside ELA Learning Components. | | December 8, 2025 | Added crosswalk fields for comparing state standards to Common Core alignments, including Jaccard similarity. | | September 23, 2025 | First release with Mathematics Standards crosswalks. | ## Related topics Review the `hasStandardAlignment` relationship and Jaccard similarity properties. Walk through a crosswalk comparison tutorial with Jaccard analysis. Find aligned standards across frameworks with similarity metrics via the REST API. # XQ Competencies Source: https://docs.learningcommons.org/knowledge-graph/datasets/standards/xq-competencies Explore the XQ Competencies dataset, a durable skills framework based on the five XQ Learner Outcomes with four-step learning progressions for grades 9-12. [Dataset last updated August 12, 2026.](#dataset-release-history) ## Overview The XQ Competencies dataset represents a [research-backed](https://xqnavigator.wpengine.com/wp-content/uploads/2025/10/XQC-Lit-Review_6.26_COMBINED_V01BA-1.pdf) durable skills framework based on the 5 XQ Learner Outcomes. It describes how students develop each competency across a 4-step learning progression in high school. | | | | :----------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Source** | [XQ Institute](https://xqsuperschool.org/) ↗'s [*XQ Competencies*](https://xqcompetencies.xqsuperschool.org/) | | **Supported grades** | 9–12 | | **Includes** | **XQ Competencies** Open
  • *Holders of Foundational Knowledge* - Core disciplines, Social Systems, Appreciating and Creating Art
  • *Masters of All Fundamental Literacies* - Communicating and Receiving Ideas, Mathematical and Scientific Thinking
  • *Original Thinkers for an Uncertain World* - Critical Thinking, Creative Thinking, Problem Seeking and Solving
  • *Generous Collaborators for Tough Problems* - Interpersonal Skills, Social Awareness, Social Agency
  • *Learners for Life* - Self-Awareness, Self-Directed Learning, Self-Management
| | **Dataset dependencies** | None | | **REST API endpoints** | [Durable skills](/api-reference/durable-skills/durable-skills-frameworks) | ## Use cases | Use case | Examples | | :-------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | | **Build rubrics and assess student work** | Use progression levels to show where a student is now and what the next level of growth looks like | | **Tag AI-generated content** | Tag or align AI-generated content and activities to specific competencies and component skills | | **Map project- and work-based learning experiences to the durable skills they develop** | Map work-based or project experiences to the durable skills they develop | | **Localize a Portrait of a Graduate** | Connect a district's high-level durable skills goals to XQ's more detailed competencies and progressions | ## Schema The data uses [standards](/knowledge-graph/schema-reference/standards#entities) entities to represent **Learner Outcomes**, **Domains**, **Competencies**, **Component Skills**, and **Progression Levels** in a 5-level tree: | | | | :----------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Data model** | XQ Competencies data model diagram | | [**Entities**](/knowledge-graph/schema-reference/standards#entities) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) (e.g., *XQ Competencies*)
  • [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) with 5 `statementType`s:
    • **Learner Outcome** — Type of person the framework aims to develop (e.g. *Learners for Life*)
    • **Domain** — Group of related competencies under a Learner Outcome
    • **Competency** — Named durable skill within a Domain
    • **Component Skill** — Specific, teachable skill within a Competency
    • **Progression Level** — i.e., Emerging, Developing, Proficient, or Applying
| | [**Relationships**](/knowledge-graph/schema-reference/standards#relationships) |
  • [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) → [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) → **Learner Outcome** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Learner Outcome** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Domain** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Domain** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Competency** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Competency** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)) → `hasChild` → **Component Skill** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
  • **Component Skill** → `hasChild` → **Progression Level** ([`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem))
| Domains have a null `description` value. Competencies have a full-prose definition (not a tagline) for the `description` field. ## Dataset release history | Date | Changed | | --------------- | ----------------------------------------------------------------------- | | August 12, 2026 | First release - added domains and domain references for each competency | ## Related topics Review entities, relationships, and property definitions for the shared `StandardsFramework` and `StandardsFrameworkItem` model. Query durable skills through the REST API — list frameworks, browse a framework's skills, and search by keyword or statement code. # Quickstart Source: https://docs.learningcommons.org/knowledge-graph/getting-started/quickstart Get started with Knowledge Graph fast. Query education data through the REST API, MCP server, ChatGPT or Claude plugins, or downloaded JSONL files. ## Using Knowledge Graph You can access Knowledge Graph data in several ways: * [Local files](#local-files) * [REST API](#rest-api) * [MCP server](#mcp-server) * AI plugins * [ChatGPT plugin](#chatgpt-plugin) * [Claude connector](#claude-connector) Each access method has its own unique [use cases and benefits](/knowledge-graph/understanding-knowledge-graph/introduction#how-to-access-knowledge-graph). ## Steps Query the Knowledge Graph for the educational data you're interested in. See [download options](/knowledge-graph/using-knowledge-graph/local-files#download). Install [`jq`](https://jqlang.github.io/jq/) ↗, a lightweight command-line JSON processor. Query your downloaded files for the data you're interested in. e.g., To get Common Core Math Standards, filter for nodes with a [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) label, a `Multi-State` [jurisdiction](/knowledge-graph/schema-reference/enums-and-formats#jurisdictionenum) (Common Core), and a `Mathematics` [academic subject](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum): ```shellscript theme={null} jq -c 'select((.labels | contains(["StandardsFrameworkItem"])) and .properties.jurisdiction == "Multi-State" and .properties.academicSubject == "Mathematics")' nodes.jsonl > common_core_math_standards.jsonl ``` Retrieve a list of [standards](/knowledge-graph/schema-reference/standards) for Multi-State Mathematics. Sign up for the [Learning Commons Platform](https://platform.learningcommons.org) ↗ to generate an API key and get your base API URL. Send a request to the `GET /standards-frameworks` API endpoint to get the `caseIdentifierUUID` for Multi-State Mathematics. ```shell cURL theme={null} curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/standards-frameworks?academicSubject=Mathematics&jurisdiction=Multi-State" ``` ```python Python theme={null} import os import requests # Setup api_key = os.getenv("API_KEY") # Your API key from Learning Commons Platform base_url = os.getenv("BASE_URL") # Your base URL from Learning Commons Platform; follows https://api.learningcommons.org/knowledge-graph/v0 format headers = { "x-api-key": api_key } response = requests.get( f"{base_url}/standards-frameworks", headers=headers, params={ "academicSubject": "Mathematics", "jurisdiction": "Multi-State" } ) result = response.json() print(result) ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; // Your API key from Learning Commons Platform const baseUrl = process.env.BASE_URL; // Your base URL from Learning Commons Platform const response = await fetch( `${baseUrl}/standards-frameworks?academicSubject=Mathematics&jurisdiction=Multi-State`, { method: 'GET', headers: { 'x-api-key': apiKey } } ); const data = await response.json(); console.log(data); ``` Copy the `caseIdentifierUUID` from the response to use in the next step. Use the `caseIdentifierUUID` with the `GET /academic-standards` API endpoint to retrieve the individual standards for that framework. ```shell cURL theme={null} curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards?standardsFrameworkCaseIdentifierUUID=YOUR_UUID_FROM_STEP_1" ``` ```python Python theme={null} import os import requests # Setup api_key = os.getenv("API_KEY") # Your API key from Learning Commons Platform base_url = os.getenv("BASE_URL") # Your base URL from Learning Commons Platform framework_uuid = "YOUR_UUID_FROM_STEP_1" # Copy from Step 1 response # Make request headers = { "x-api-key": api_key } response = requests.get( f"{base_url}/academic-standards", headers=headers, params={ "standardsFrameworkCaseIdentifierUUID": framework_uuid } ) result = response.json() print(result) ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; // Your API key from Learning Commons Platform const baseUrl = process.env.BASE_URL; // Your base URL from Learning Commons Platform const frameworkUuid = "YOUR_UUID_FROM_STEP_1"; // From Step 1 response const response = await fetch( `${baseUrl}/academic-standards?standardsFrameworkCaseIdentifierUUID=${frameworkUuid}`, { method: 'GET', headers: { 'x-api-key': apiKey } } ); const data = await response.json(); console.log(data); ``` ```json Response theme={null} { "data": [ { "identifier": "e1755456-c533-5a84-891e-59725c0479e0", "caseIdentifierURI": "https://satchelcommons.com/ims/case/v1p0/CFItems/6b9bf846-d7cc-11e8-824f-0242ac160002", "caseIdentifierUUID": "6b9bf846-d7cc-11e8-824f-0242ac160002", "name": null, "statementCode": "3.NF.A.1", "description": "Understand a fraction $\\frac{1}{b}$ as the quantity formed by 1 part when a whole is partitioned into b equal parts; understand a fraction $\\frac{a}{b}$ as the quantity formed by a parts of size $\\frac{1}{b}$.", "statementType": "Standard", "normalizedStatementType": "Standard", "jurisdiction": "Multi-State", "academicSubject": "Mathematics", "gradeLevel": ["3"], "inLanguage": "en-US", "dateCreated": null, "dateModified": "2025-02-05", "notes": null, "author": "1EdTech", "provider": "Learning Commons", "license": "https://creativecommons.org/licenses/by/4.0/", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received state standards and written permission under CC BY-4.0 from 1EdTech." } ], "pagination": { "limit": 1, "nextCursor": "eyJpZGVudGlmaWVyIjogImUxNzU1NDU2LWM1MzMtNWE4NC04OTFlLTU5NzI1YzA0NzllMCJ9", "hasMore": true } } ``` Ask about [standards](/knowledge-graph/schema-reference/standards), [learning components](/knowledge-graph/schema-reference/learning-components), or [learning progressions](/knowledge-graph/schema-reference/learning-progressions). Sign up for the [Learning Commons Platform](https://platform.learningcommons.org) ↗ to generate an API key. Download an AI client that supports MCP (e.g., OpenAI with the Responses API). ```txt .env theme={null} OPENAI_API_KEY= MCP_AUTH_KEY= MCP_SERVER_URL=https://kg.mcp.learningcommons.org/mcp ``` Make a request to the MCP server with your question – e.g., "What are the learning components for California standard 4.OA.A.3?" ```python Python theme={null} import os import requests from dotenv import load_dotenv load_dotenv() response = requests.post( "https://api.openai.com/v1/responses", headers={ "Content-Type": "application/json", "Authorization": f"Bearer {os.getenv('OPENAI_API_KEY')}", }, json={ "model": "gpt-4o", "tools": [ { "type": "mcp", "server_label": "learning-commons-kg", "server_url": os.getenv("MCP_SERVER_URL"), "require_approval": "never", "headers": {"x-api-key": os.getenv("MCP_AUTH_KEY")}, } ], "input": "What are the learning components for California standard 4.OA.A.3?", }, ) print(response.json()) ``` ```javascript JavaScript theme={null} import "dotenv/config"; const response = await fetch("https://api.openai.com/v1/responses", { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${process.env.OPENAI_API_KEY}`, }, body: JSON.stringify({ model: "gpt-4o", tools: [ { type: "mcp", server_label: "learning-commons-kg", server_url: process.env.MCP_SERVER_URL, require_approval: "never", headers: {"x-api-key": process.env.MCP_AUTH_KEY}, }, ], input: "What are the learning components for California standard 4.OA.A.3?", }), }); console.log(await response.json()); ``` If using an SDK, verify how to pass in the MCP authorization key for your client. Your AI client will call Knowledge Graph MCP tools to return structured results (e.g., [standard](/knowledge-graph/schema-reference/standards) statements, [learning components](/knowledge-graph/schema-reference/learning-components), etc.). Inspect `mcp_call` output entries for tool names, arguments, and results. Get authoritative [standards](/knowledge-graph/schema-reference/standards) data when asking about a standard code. Search for **Learning Commons** in the ChatGPT plugin library and add it to your account. The plugin is included in OpenAI's K-12 Educator plugin experience for [ChatGPT for Teachers](https://chatgpt.com/plans/k12-teachers/) ↗ (US K-12) and ChatGPT Education. Individual ChatGPT users may also be able to add it depending on their plan and available plugin settings. Learning Commons ChatGPT plugin Ask ChatGPT questions about a standard. Mention the grade level, state, and/or standard code (e.g., `5.NBT.A.2` or `RL.4.1`) that you are interested in: * "I'm a teacher in Utah. Generate 3 project ideas that address standard 3.W\.1." * "I am a 4th-grade teacher in California. A student is struggling with 4.OA.A.3. Which prior standards should I focus on?" ChatGPT will use Knowledge Graph tools to look up the official statement, break [standards](/knowledge-graph/schema-reference/standards) into [learning components](/knowledge-graph/schema-reference/learning-components), and trace [learning progressions](/knowledge-graph/schema-reference/learning-progressions). Get authoritative [standards](/knowledge-graph/schema-reference/standards) data when asking about a standard code. Sign up for a [Claude](https://claude.ai/) ↗ account. Set up the [Knowledge Graph integration in Claude](https://claude.ai/directory/6e94f5fc-5dc8-4f0a-9fcf-741bcab4e034) ↗ from the Claude connector directory. Learning Commons Claude Connector Ask Claude questions about a standard. Mention the grade level, state, and/or standard code (e.g., `5.NBT.A.2` or `RL.4.1`) that you are interested in: * "I'm a teacher in Iowa. Generate three project ideas that address W\.3.4." * "I am a 4th-grade teacher in California. A student is struggling with 4.OA.A.3. Which prior standards should I focus on?" Claude will use Knowledge Graph tools to look up the official statement, break [standards](/knowledge-graph/schema-reference/standards) into [learning components](/knowledge-graph/schema-reference/learning-components), and trace [learning progressions](/knowledge-graph/schema-reference/learning-progressions). ## Related topics Explore API endpoints to access Knowledge Graph data programmatically. Follow a step-by-step tutorial to query frameworks and tag content. # Compare Common Core and state frameworks Source: https://docs.learningcommons.org/knowledge-graph/getting-started/tutorials/compare-common-core-and-state-frameworks Learn how to use Knowledge Graph crosswalk data to compare standards between jurisdictions using Jaccard scores and learning components. Use Knowledge Graph's [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) to compare CCSSM and state frameworks' [standards](/knowledge-graph/schema-reference/standards). Standards crosswalks interpret how closely 2 standards' [Learning Components](/knowledge-graph/schema-reference/learning-components) align. Diagram: state mathematics standards linked to Common Core standards via hasStandardAlignment, with Jaccard similarity and shared Learning Components The diagram shows the **U.S. academic standards crosswalks** dataset only: state mathematics standards mapped to Common Core State Standards. Both endpoints are `StandardsFrameworkItem` (defined in [Standards](/knowledge-graph/schema-reference/standards)). Direction is always state → CCSS, not between states. Edge properties include jaccard and LC counts; see [`hasStandardAlignment`](/knowledge-graph/schema-reference/standards#hasstandardalignment). **Example (New York → CCSS):** A **state standard** is a `StandardsFrameworkItem` from a state framework—e.g. *NY 3.NF.1 (Understand a fraction 1/b as the quantity formed by 1 part when a whole is partitioned into b equal parts)*. A **CCSS standard** is a `StandardsFrameworkItem` from Common Core Math—e.g. *3.NF.A.1*. A **hasStandardAlignment** edge connects them when they share at least one Learning Component; the edge has properties such as `jaccard` (e.g. 0.85), `stateLCCount`, `ccssLCCount`, `sharedLCCount`. So: NY 3.NF.1 -\[:hasStandardAlignment]-> 3.NF.A.1. Crosswalks are only state → CCSS (never state → state). **Edge list (source → relationship → target):**
  • `StandardsFrameworkItem` (state) → `hasStandardAlignment` → `StandardsFrameworkItem` (CCSS) (e.g. NY 3.NF.1 → 3.NF.A.1)
## What you'll do * Identify the closest Texas standards for a given CCSSM standard * Interpret alignment strength using Jaccard scores and LC counts * Inspect the shared Learning Components that support each alignment ## What you'll need * API key and base URL in the [Learning Commons Platform](https://platform.learningcommons.org) ↗ * Familiarity with the [`GET /academic-standards/search`](/api-reference/academic-standards/search-standards), [`GET /academic-standards/{uuid}/crosswalks`](/api-reference/standards-crosswalks/crosswalks-for-a-standard), and [`GET /academic-standards/{uuid}/learning-components`](/api-reference/learning-components/learning-components-for-a-standard) API endpoints * [`curl`](https://github.com/curl/curl) ↗, Python, or Node ## Steps ```text .env theme={null} API_KEY=your_api_key_here BASE_URL=https://api.learningcommons.org/knowledge-graph/v0 ``` First, use [`GET /academic-standards/search`](/api-reference/academic-standards/search-standards) to find the 6.EE.B.5 CCSSM standard. Then, use [`GET /academic-standards/{uuid}/crosswalks`](/api-reference/standards-crosswalks/crosswalks-for-a-standard) to get Texas standards that share Learning Components with that CCSSM standard. ```shell cURL theme={null} curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/search?statementCode=6.EE.B.5&jurisdiction=Multi-State" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5" TARGET_CCSSM_JURISDICTION = "Multi-State" headers = {"x-api-key": api_key} # Find the CCSSM standard by its statement code and jurisdiction search_response = requests.get( f"{base_url}/academic-standards/search", headers=headers, params={ "statementCode": TARGET_CCSSM_STANDARD_CODE, "jurisdiction": TARGET_CCSSM_JURISDICTION } ) search_result = search_response.json() ccssm_standard = search_result[0] if search_result else None if not ccssm_standard: print(f'❌ CCSSM standard not found: {TARGET_CCSSM_STANDARD_CODE}') else: ccssm_standard_uuid = ccssm_standard['caseIdentifierUUID'] print(f'✅ Found CCSSM standard: {TARGET_CCSSM_STANDARD_CODE}') print(f' Case UUID: {ccssm_standard_uuid}') print(f' Description: {ccssm_standard["description"]}') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; const TARGET_CCSSM_STANDARD_CODE = "6.EE.B.5"; const TARGET_CCSSM_JURISDICTION = "Multi-State"; // Find the CCSSM standard by its statement code and jurisdiction const searchResponse = await fetch( `${baseUrl}/academic-standards/search?statementCode=${TARGET_CCSSM_STANDARD_CODE}&jurisdiction=${TARGET_CCSSM_JURISDICTION}`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const searchResult = await searchResponse.json(); const ccssmStandard = searchResult[0] || null; if (!ccssmStandard) { console.log(`❌ CCSSM standard not found: ${TARGET_CCSSM_STANDARD_CODE}`); } else { const ccssmStandardUuid = ccssmStandard.caseIdentifierUUID; console.log(`✅ Found CCSSM standard: ${TARGET_CCSSM_STANDARD_CODE}`); console.log(` Case UUID: ${ccssmStandardUuid}`); console.log(` Description: ${ccssmStandard.description}`); } ``` ```json Response theme={null} { "caseIdentifierUUID": "6b9f74c0-d7cc-11e8-824f-0242ac160002", "statementCode": "6.EE.B.5", "description": "Understand solving an equation or inequality as a process of answering a question: which values from a specified set, if any, make the equation or inequality true? Use substitution to determine whether a given number in a specified set makes an equation or inequality true.", "jurisdiction": "Multi-State" } ``` Use the `GET /academic-standards/{caseIdentifierUUID}/crosswalks` API endpoint with the `caseIdentifierUUID` from your response: ```shell cURL theme={null} # Replace CCSSM_UUID with the caseIdentifierUUID from the previous step curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/crosswalks?jurisdiction=Texas" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") headers = {"x-api-key": api_key} # ccssm_standard_uuid from previous step crosswalk_response = requests.get( f"{base_url}/academic-standards/{ccssm_standard_uuid}/crosswalks", headers=headers, params={"jurisdiction": "Texas"} ) crosswalk_result = crosswalk_response.json() texas_matches = crosswalk_result["data"] if not texas_matches: print(f'❌ No Texas standard matches found for {TARGET_CCSSM_STANDARD_CODE}') else: # Sort by Jaccard score (highest first) texas_matches_sorted = sorted(texas_matches, key=lambda x: x['jaccard'], reverse=True) print(f'\n✅ Found {len(texas_matches_sorted)} Texas standard matches') print(f'\n📊 Top Texas match (highest Jaccard score):') top_match = texas_matches_sorted[0] print(f' Statement Code: {top_match["statementCode"]}') print(f' Jaccard Score: {top_match["jaccard"]:.4f}') print(f' Shared LC Count: {top_match["sharedLCCount"]}') print(f' State LC Count: {top_match["stateLCCount"]}') print(f' CCSS LC Count: {top_match["ccssLCCount"]}') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; // ccssmStandardUuid from previous step const crosswalkResponse = await fetch( `${baseUrl}/academic-standards/${ccssmStandardUuid}/crosswalks?jurisdiction=Texas`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const crosswalkResult = await crosswalkResponse.json(); let texasMatches = crosswalkResult.data; if (!texasMatches || texasMatches.length === 0) { console.log( `❌ No Texas standard matches found for ${TARGET_CCSSM_STANDARD_CODE}`, ); } else { // Sort by Jaccard score (highest first) const texasMatchesSorted = texasMatches.sort((a, b) => b.jaccard - a.jaccard); console.log(`\n✅ Found ${texasMatchesSorted.length} Texas standard matches`); console.log(`\n📊 Top Texas match (highest Jaccard score):`); const topMatch = texasMatchesSorted[0]; console.log(` Statement Code: ${topMatch.statementCode}`); console.log(` Jaccard Score: ${topMatch.jaccard.toFixed(4)}`); console.log(` Shared LC Count: ${topMatch.sharedLCCount}`); console.log(` State LC Count: ${topMatch.stateLCCount}`); console.log(` CCSS LC Count: ${topMatch.ccssLCCount}`); } ``` The response contains the Texas standards that share Learning Components with your target 6.EE.B.5 CCSSM standard, with overlap metrics: ```json Response theme={null} { "data": [ { "caseIdentifierUUID": "18077fab-3aac-5dcc-89da-f8081e9045bd", "statementCode": "111.27.b.11.B", "description": "determine if the given value(s) make(s) one-variable, two-step equations and inequalities true; and", "jurisdiction": "Texas", "jaccard": 0.6667, "stateLCCount": 2, "ccssLCCount": 3, "sharedLCCount": 2 }, { "caseIdentifierUUID": "005fc52f-b920-506c-bea1-6857b886f6b6", "statementCode": "111.26.b.10.B", "description": "determine if the given value(s) make(s) one-variable, one-step equations or inequalities true.", "jurisdiction": "Texas", "jaccard": 0.2, "stateLCCount": 3, "ccssLCCount": 3, "sharedLCCount": 1 } ] } ``` A [Jaccard score](/knowledge-graph/schema-reference/standards#understanding-the-jaccard-score) of 1.0 means the standards have identical Learning Components. An index of 0.0 indicates no overlap. A Jaccard score of 0.6 is a good starting point for identifying strong matches, but you can adjust this threshold based on your use case. Each crosswalk relationship carries additional context about the degree of overlap: * `sharedLCCount` – Number of shared deconstructed skills * `stateLCCount` – Number of skills that support the state standard * `ccssLCCount` – Number of skills that support the CCSSM standard With the Jaccard score, these counts help you interpret the strength and balance of the overlap (e.g. does one standard cover more ground than the other? Are their scopes comparable?). Now that you have crosswalk pairs (CCSSM → Texas), retrieve the actual skills (i.e. Learning Components) that support each standard. ```shell cURL theme={null} # Get Learning Components for CCSS standard curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/6b9f74c0-d7cc-11e8-824f-0242ac160002/learning-components" # Get Learning Components for Texas standard (using the top match from the previous step) curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/18077fab-3aac-5dcc-89da-f8081e9045bd/learning-components" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") headers = {"x-api-key": api_key} # Use the top match from the previous step top_match = texas_matches_sorted[0] state_standard_uuid = top_match['caseIdentifierUUID'] # Get LCs that support the CCSS standard ccss_lc_response = requests.get( f"{base_url}/academic-standards/{ccssm_standard_uuid}/learning-components", headers=headers ) ccss_lc_result = ccss_lc_response.json() ccss_lcs = ccss_lc_result["data"] # Get LCs that support the state standard state_lc_response = requests.get( f"{base_url}/academic-standards/{state_standard_uuid}/learning-components", headers=headers ) state_lc_result = state_lc_response.json() state_lcs = state_lc_result["data"] # Create sets of LC identifiers for comparison ccss_lc_ids = {lc['identifier'] for lc in ccss_lcs} state_lc_ids = {lc['identifier'] for lc in state_lcs} # Find shared and unique LCs shared_lc_ids = ccss_lc_ids & state_lc_ids ccss_only_ids = ccss_lc_ids - state_lc_ids state_only_ids = state_lc_ids - ccss_lc_ids # Get LC descriptions shared_lcs = [lc for lc in ccss_lcs if lc['identifier'] in shared_lc_ids] ccss_only_lcs = [lc for lc in ccss_lcs if lc['identifier'] in ccss_only_ids] state_only_lcs = [lc for lc in state_lcs if lc['identifier'] in state_only_ids] print(f'\n✅ LEARNING COMPONENTS ANALYSIS:') print(f'CCSS Standard: {ccssm_standard["statementCode"]}') print(f'State Standard: {top_match["statementCode"]}') print() print(f'📊 SHARED LEARNING COMPONENTS ({len(shared_lcs)}):') for idx, lc in enumerate(shared_lcs, 1): print(f' ✅ {idx}. {lc["description"]}') print() print(f'📊 CCSS-ONLY LEARNING COMPONENTS ({len(ccss_only_lcs)}):') for idx, lc in enumerate(ccss_only_lcs, 1): print(f' ➕ {idx}. {lc["description"]}') print() print(f'📊 STATE-ONLY LEARNING COMPONENTS ({len(state_only_lcs)}):') for idx, lc in enumerate(state_only_lcs, 1): print(f' ➖ {idx}. {lc["description"]}') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; // Use the top match from the previous step const topMatch = texasMatchesSorted[0]; const stateStandardUuid = topMatch.caseIdentifierUUID; // Get LCs that support the CCSS standard const ccssLcResponse = await fetch( `${baseUrl}/academic-standards/${ccssmStandardUuid}/learning-components`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const ccssLcResult = await ccssLcResponse.json(); const ccssLcs = ccssLcResult.data; // Get LCs that support the state standard const stateLcResponse = await fetch( `${baseUrl}/academic-standards/${stateStandardUuid}/learning-components`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const stateLcResult = await stateLcResponse.json(); const stateLcs = stateLcResult.data; // Create sets of LC identifiers for comparison const ccssLcIds = new Set(ccssLcs.map((lc) => lc.identifier)); const stateLcIds = new Set(stateLcs.map((lc) => lc.identifier)); // Find shared and unique LCs const sharedLcIds = new Set([...ccssLcIds].filter((id) => stateLcIds.has(id))); const ccssOnlyIds = new Set([...ccssLcIds].filter((id) => !stateLcIds.has(id))); const stateOnlyIds = new Set( [...stateLcIds].filter((id) => !ccssLcIds.has(id)), ); // Get LC descriptions const sharedLcs = ccssLcs.filter((lc) => sharedLcIds.has(lc.identifier)); const ccssOnlyLcs = ccssLcs.filter((lc) => ccssOnlyIds.has(lc.identifier)); const stateOnlyLcs = stateLcs.filter((lc) => stateOnlyIds.has(lc.identifier)); console.log(`\n✅ LEARNING COMPONENTS ANALYSIS:`); console.log(`CCSS Standard: ${ccssmStandard.statementCode}`); console.log(`State Standard: ${topMatch.statementCode}`); console.log(); console.log(`📊 SHARED LEARNING COMPONENTS (${sharedLcs.length}):`); sharedLcs.forEach((lc, idx) => { console.log(` ✅ ${idx + 1}. ${lc.description}`); }); console.log(); console.log(`📊 CCSS-ONLY LEARNING COMPONENTS (${ccssOnlyLcs.length}):`); ccssOnlyLcs.forEach((lc, idx) => { console.log(` ➕ ${idx + 1}. ${lc.description}`); }); console.log(); console.log(`📊 STATE-ONLY LEARNING COMPONENTS (${stateOnlyLcs.length}):`); stateOnlyLcs.forEach((lc, idx) => { console.log(` ➖ ${idx + 1}. ${lc.description}`); }); ``` This analysis reveals the Learning Components that are present in both standards, and the Learning Components that are unique to either the CCSS or state standard. Now that you understand which Learning Components are shared vs. unique, you can make informed decisions about how to adapt your content to align to curriculum standards. Explore other [Standards crosswalks](/knowledge-graph/schema-reference/standards#hasstandardalignment) to compare other states' standards to Common Core and to guide alignment work across frameworks in your own edtech product. ## Related topics Explore standards alignment, planning, crosswalks, curriculum, and assessment workflows. Query frameworks and standards in a step-by-step tutorial. Use progressions to find prerequisites and generate practice content. # Generate practice questions Source: https://docs.learningcommons.org/knowledge-graph/getting-started/tutorials/generate-practice-questions Follow this tutorial to find prerequisite math standards in Knowledge Graph and use their learning components to generate practice questions with an LLM. Query Knowledge Graph for the prerequisite standards for a given [standard](/knowledge-graph/schema-reference/standards). Generate practice questions using these prerequisite standards' [learning components](/knowledge-graph/schema-reference/learning-components). Our current [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) dataset from [Student Achievement Partners](https://learnwithsap.org/) ↗ (SAP) maps Common Core State Standards for Mathematics into logical sequences. These sequences do not name definitive prerequisites – their relationships simply indicate what might be helpful in a given circumstance. ## What you'll do * Find prerequisite standards for a target CCSS standard using the [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) * Unpack prerequisite standards into supporting [learning components](/knowledge-graph/schema-reference/learning-components) * Package Knowledge Graph data for an LLM to generate practice questions ## What you'll need * API key and base URL in the [Learning Commons Platform](https://platform.learningcommons.org/) ↗ * OpenAI API key and SDK (`pip install openai` for Python or `npm install openai` for JavaScript) * [`curl`](https://github.com/curl/curl) ↗, Python, or Node ## Steps ```text .env theme={null} API_KEY=your_api_key_here BASE_URL=https://api.learningcommons.org/knowledge-graph/v0 OPENAI_API_KEY=your_openai_api_key_here ``` Use the [`GET /academic-standards/search`](/api-reference/academic-standards/search-standards) endpoint to find the 6.NS.B.4 standard. Then, use [`GET /academic-standards/{uuid}/prerequisites`](/api-reference/academic-standards/prerequisites-for-a-standard) to get its prerequisites: ```shell cURL theme={null} # Step 1: Find the target standard by statement code curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/search?statementCode=6.NS.B.4&jurisdiction=Multi-State" # Step 2: Get prerequisites using the caseIdentifierUUID from Step 1 curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/YOUR_UUID/prerequisites" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") TARGET_CODE = "6.NS.B.4" headers = {"x-api-key": api_key} # Find the target standard by statement code search_response = requests.get( f"{base_url}/academic-standards/search", headers=headers, params={ "statementCode": TARGET_CODE, "jurisdiction": "Multi-State" } ) search_result = search_response.json() target_standard = search_result[0] if search_result else None if not target_standard: print(f'❌ No standard found for {TARGET_CODE}') else: print(f'✅ Found standard {TARGET_CODE}:') print(f' UUID: {target_standard["caseIdentifierUUID"]}') print(f' Description: {target_standard["description"]}') # Get prerequisites prereq_response = requests.get( f"{base_url}/academic-standards/{target_standard['caseIdentifierUUID']}/prerequisites", headers=headers ) prereq_result = prereq_response.json() prerequisite_standards = prereq_result["data"] print(f'✅ Found {len(prerequisite_standards)} prerequisite(s):') for prereq in prerequisite_standards: print(f' {prereq["statementCode"]}: {prereq["description"][:80]}...') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; const TARGET_CODE = "6.NS.B.4"; // Find the target standard by statement code const searchResponse = await fetch( `${baseUrl}/academic-standards/search?statementCode=${TARGET_CODE}&jurisdiction=Multi-State`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const searchResult = await searchResponse.json(); const targetStandard = searchResult[0] || null; if (!targetStandard) { console.error(`❌ No standard found for ${TARGET_CODE}`); } else { console.log(`✅ Found standard ${TARGET_CODE}:`); console.log(` UUID: ${targetStandard.caseIdentifierUUID}`); console.log(` Description: ${targetStandard.description}`); // Get prerequisites const prereqResponse = await fetch( `${baseUrl}/academic-standards/${targetStandard.caseIdentifierUUID}/prerequisites`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const prereqResult = await prereqResponse.json(); const prerequisiteStandards = prereqResult.data; console.log(`✅ Found ${prerequisiteStandards.length} prerequisite(s):`); prerequisiteStandards.forEach((prereq) => { console.log( ` ${prereq.statementCode}: ${prereq.description.substring(0, 80)}...`, ); }); } ``` ```json Response theme={null} [ { "caseIdentifierUUID": "6b9ed00e-d7cc-11e8-824f-0242ac160002", "statementCode": "4.OA.B.4", "standardDescription": "A buildsTowards relationship indicates that proficiency in one entity supports the likelihood of success in another, capturing a directional progression without requiring strict prerequisite order." } // ... ] ``` Use the [`GET /academic-standards/{uuid}/learning-components`](/api-reference/learning-components/learning-components-for-a-standard) endpoint for each prerequisite standard: ```shell cURL theme={null} # Get Learning Components for a prerequisite standard # Replace PREREQ_UUID with each prerequisite's caseIdentifierUUID curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards/PREREQ_UUID/learning-components" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") headers = {"x-api-key": api_key} # prerequisite_standards from previous step prerequisite_learning_components = [] for prereq in prerequisite_standards: lc_response = requests.get( f"{base_url}/academic-standards/{prereq['caseIdentifierUUID']}/learning-components", headers=headers ) lc_result = lc_response.json() for lc in lc_result["data"]: prerequisite_learning_components.append({ "caseIdentifierUUID": prereq["caseIdentifierUUID"], "statementCode": prereq["statementCode"], "standardDescription": prereq["description"], "learningComponentDescription": lc["description"] }) print(f'✅ Found {len(prerequisite_learning_components)} supporting Learning Components for prerequisites:') for lc in prerequisite_learning_components[:5]: print(f' {lc["learningComponentDescription"][:80]}...') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; // prerequisiteStandards from previous step const prerequisiteLearningComponents = []; for (const prereq of prerequisiteStandards) { const lcResponse = await fetch( `${baseUrl}/academic-standards/${prereq.caseIdentifierUUID}/learning-components`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const lcResult = await lcResponse.json(); for (const lc of lcResult.data) { prerequisiteLearningComponents.push({ caseIdentifierUUID: prereq.caseIdentifierUUID, statementCode: prereq.statementCode, standardDescription: prereq.description, learningComponentDescription: lc.description, }); } } console.log( `✅ Found ${prerequisiteLearningComponents.length} supporting Learning Components for prerequisites:`, ); prerequisiteLearningComponents.slice(0, 5).forEach((lc) => { console.log(` ${lc.learningComponentDescription.substring(0, 80)}...`); }); ``` ```json Response theme={null} [ { "caseIdentifierUUID": "6b9d5f43-d7cc-11e8-824f-0242ac160002", "statementCode": "5.OA.A.2", "standardDescription": "A buildsTowards relationship indicates that proficiency in one entity supports the likelihood of success in another, capturing a directional progression without requiring strict prerequisite order.", "learningComponentDescription": "Write simple expressions of two or more steps and with grouping symbols that record calculations with numbers" } // ... ] ``` You will use the `prerequisiteLearningComponents` array to generate practice questions in the next step. Package the Standards and Learning Components data to generate practice questions. ```javascript JavaScript theme={null} function packageContextData(targetStandard, prerequisiteLearningComponents) { // Package the Standards and Learning Components data for text generation const standardsMap = new Map(); // Group Learning Components by Academic Standard for context for (const row of prerequisiteLearningComponents) { if (!standardsMap.has(row.caseIdentifierUUID)) { standardsMap.set(row.caseIdentifierUUID, { statementCode: row.statementCode, description: row.standardDescription || "(no statement)", supportingLearningComponents: [], }); } standardsMap.get(row.caseIdentifierUUID).supportingLearningComponents.push({ description: row.learningComponentDescription || "(no description)", }); } const fullStandardsContext = { targetStandard: { statementCode: targetStandard.statementCode, description: targetStandard.description || "(no statement)", }, prereqStandards: Array.from(standardsMap.values()), }; return fullStandardsContext; } ``` ```python Python theme={null} def package_context_data(target_standard, prerequisite_learning_components): # Package the Standards and Learning Components data for text generation standards_map = {} # Group Learning Components by Standard for context for row in prerequisite_learning_components: case_id = row['caseIdentifierUUID'] if case_id not in standards_map: standards_map[case_id] = { 'statementCode': row['statementCode'], 'description': row['standardDescription'] or '(no statement)', 'supportingLearningComponents': [] } standards_map[case_id]['supportingLearningComponents'].append({ 'description': row['learningComponentDescription'] or '(no description)' }) full_standards_context = { 'targetStandard': { 'statementCode': target_standard['statementCode'], 'description': target_standard['description'] or '(no statement)' }, 'prereqStandards': list(standards_map.values()) } print('✅ Packaged full standards context for text generation') return full_standards_context ``` Use that JSON in a prompt so the LLM has full context when creating practice questions: ```javascript JavaScript theme={null} const OpenAI = require("openai"); const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); const OPENAI_MODEL = "gpt-4"; const OPENAI_TEMPERATURE = 0.7; async function generatePractice(fullStandardsContext) { console.log( `🔄 Generating practice questions for ${fullStandardsContext.targetStandard.statementCode}...`, ); try { // Build prompt inline let prerequisiteText = ""; for (const prereq of fullStandardsContext.prereqStandards) { prerequisiteText += `- ${prereq.statementCode}: ${prereq.description}\n`; prerequisiteText += " Supporting Learning Components:\n"; for (const lc of prereq.supportingLearningComponents) { prerequisiteText += ` • ${lc.description}\n`; } } const prompt = `You are a math tutor helping middle school students. Based on the following information, generate 3 practice questions for the target standard. Questions should help reinforce the key concept and build on prerequisite knowledge. Target Standard: - ${fullStandardsContext.targetStandard.statementCode}: ${fullStandardsContext.targetStandard.description} Prerequisite Standards & Supporting Learning Components: ${prerequisiteText}`; const response = await openai.chat.completions.create({ model: OPENAI_MODEL, messages: [ { role: "system", content: "You are an expert middle school math tutor.", }, { role: "user", content: prompt }, ], temperature: OPENAI_TEMPERATURE, }); const practiceQuestions = response.choices[0].message.content.trim(); console.log(`✅ Generated practice questions:\n`); console.log(practiceQuestions); return { aiGenerated: practiceQuestions, targetStandard: fullStandardsContext.targetStandard.statementCode, prerequisiteCount: fullStandardsContext.prereqStandards.length, }; } catch (err) { console.error("❌ Error generating practice questions:", err.message); throw err; } } ``` ```python Python theme={null} from openai import OpenAI openai_client = OpenAI( api_key=os.getenv('OPENAI_API_KEY') ) OPENAI_MODEL = 'gpt-4' OPENAI_TEMPERATURE = 0.7 def generate_practice(full_standards_context): print(f'🔄 Generating practice questions for {full_standards_context["targetStandard"]["statementCode"]}...') try: # Build prompt inline prerequisite_text = '' for prereq in full_standards_context['prereqStandards']: prerequisite_text += f'- {prereq["statementCode"]}: {prereq["description"]}\n' prerequisite_text += ' Supporting Learning Components:\n' for lc in prereq['supportingLearningComponents']: prerequisite_text += f' • {lc["description"]}\n' prompt = f"""You are a math tutor helping middle school students. Based on the following information, generate 3 practice questions for the target standard. Questions should help reinforce the key concept and build on prerequisite knowledge. Target Standard: - {full_standards_context["targetStandard"]["statementCode"]}: {full_standards_context["targetStandard"]["description"]} Prerequisite Standards & Supporting Learning Components: {prerequisite_text}""" response = openai_client.chat.completions.create( model=OPENAI_MODEL, messages=[ {'role': 'system', 'content': 'You are an expert middle school math tutor.'}, {'role': 'user', 'content': prompt} ], temperature=OPENAI_TEMPERATURE ) practice_questions = response.choices[0].message.content.strip() print('✅ Generated practice questions:\n') print(practice_questions) return { 'aiGenerated': practice_questions, 'targetStandard': full_standards_context['targetStandard']['statementCode'], 'prerequisiteCount': len(full_standards_context['prereqStandards']) } except Exception as err: print(f'❌ Error generating practice questions: {str(err)}') raise err ``` ```text Example response theme={null} Question 1: Find the greatest common factor of 36 and 90. Then use the distributive property to express the sum of these two numbers as a multiple of a sum of two whole numbers with no common factor. Question 2: Write the expression "add 12 and 15, then multiply by 3" as an algebraic expression. After that, recognize that this expression is three times as large as 12 + 15, without having to calculate the indicated sum or product. Question 3: Determine whether the number 72 is a multiple of the digit 8. Find all factor pairs of 72. Recognize that 72 is a multiple of each of its factors and determine whether 72 is a prime or a composite number. ``` You can now integrate these practice questions into your product workflow! We scoped to a single standard for clarity, but you can also extend prerequisite chains across grade levels or explore other target standards and subject areas. For more comprehensive learning experiences, extend your queries to include lessons, assessments, or instructional routines. ## Related topics Explore standards alignment, planning, crosswalks, curriculum, and assessment workflows. Query frameworks and standards in a step-by-step tutorial. Walk through a crosswalk comparison tutorial with Jaccard analysis. # Tag content to state standards Source: https://docs.learningcommons.org/knowledge-graph/getting-started/tutorials/tag-content-to-state-standards Learn how to query Knowledge Graph standards frameworks and individual standards, with optional embedding generation for vector search. Query the Knowledge Graph's [standards](/knowledge-graph/schema-reference/standards) for middle school math standards in California. ## What you'll do * Query the Knowledge Graph for the California math standards framework * Narrow down to specific grades' standards groupings (i.e., middle school) * List all individual middle school math standards in California * Use your findings to tag your educational content accordingly ## What you'll need * API key and base URL in the [Learning Commons Platform](https://platform.learningcommons.org/) ↗ * [`curl`](https://github.com/curl/curl) ↗, Python, or Node ## Steps ```text .env theme={null} API_KEY=your_api_key_here BASE_URL=https://api.learningcommons.org/knowledge-graph/v0 ``` Reference the [standards](/knowledge-graph/schema-reference/standards) docs for the underlying entities and relationships. Use the [`GET /standards-frameworks`](/api-reference/academic-standards/standards-frameworks) API endpoint with `jurisdiction` and `academicSubject` filters: ```shell cURL theme={null} curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/standards-frameworks?jurisdiction=California&academicSubject=Mathematics" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") headers = {"x-api-key": api_key} # Get California math standards framework response = requests.get( f"{base_url}/standards-frameworks", headers=headers, params={ "jurisdiction": "California", "academicSubject": "Mathematics" } ) result = response.json() california_framework = result["data"][0] if result["data"] else None print(f'✅ Retrieved California math standards framework:') print(california_framework) ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; // Get California math standards framework const response = await fetch( `${baseUrl}/standards-frameworks?jurisdiction=California&academicSubject=Mathematics`, { method: "GET", headers: { "x-api-key": apiKey }, }, ); const result = await response.json(); const californiaFramework = result.data[0] || null; console.log("✅ Retrieved California math standards framework:"); console.log(californiaFramework); ``` ```json Response theme={null} { "caseIdentifierUUID": "c6487102-d7cb-11e8-824f-0242ac160002", "name": "California Common Core State Standards - Mathematics", "jurisdiction": "California", "academicSubject": "Mathematics" } ``` States often group their standards by clusters, domains, etc. These sets of related standards are called standard groupings. Use the [`GET /academic-standards`](/api-reference/academic-standards/standards-in-a-framework) API endpoint with `normalizedStatementType` and `gradeLevel` filters: ```shell cURL theme={null} # Replace YOUR_FRAMEWORK_UUID with the caseIdentifierUUID from the previous step curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards?standardsFrameworkCaseIdentifierUUID=YOUR_FRAMEWORK_UUID&normalizedStatementType=Standard+Grouping&gradeLevel=6&gradeLevel=7&gradeLevel=8" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") framework_uuid = "c6487102-d7cb-11e8-824f-0242ac160002" # California Math from Step 2 headers = {"x-api-key": api_key} # Get middle school standard groupings response = requests.get( f"{base_url}/academic-standards", headers=headers, params={ "standardsFrameworkCaseIdentifierUUID": framework_uuid, "normalizedStatementType": "Standard Grouping", "gradeLevel": ["6", "7", "8"] } ) result = response.json() groupings = result["data"] print(f'✅ Retrieved {len(groupings)} standard groupings for middle school math in California') for grouping in groupings[:5]: print(f' {grouping["statementCode"]}: {grouping["description"][:80]}...') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; const frameworkUuid = "c6487102-d7cb-11e8-824f-0242ac160002"; // California Math from Step 2 // Get middle school standard groupings const params = new URLSearchParams({ standardsFrameworkCaseIdentifierUUID: frameworkUuid, normalizedStatementType: "Standard Grouping", }); // Add multiple grade levels ["6", "7", "8"].forEach((grade) => params.append("gradeLevel", grade)); const response = await fetch(`${baseUrl}/academic-standards?${params}`, { method: "GET", headers: { "x-api-key": apiKey }, }); const result = await response.json(); const groupings = result.data; console.log( `✅ Retrieved ${groupings.length} standard groupings for middle school math in California`, ); groupings.slice(0, 5).forEach((g) => { console.log(` ${g.statementCode}: ${g.description.substring(0, 80)}...`); }); ``` ```json Response theme={null} [ { "caseIdentifierUUID": "5ebeb890-d7cc-11e8-824f-0242ac160002", "statementCode": "6.RP.A", "description": "Understand ratio concepts and use ratio reasoning to solve problems.", "normalizedStatementType": "Standard Grouping", "statementType": "Cluster", "gradeLevel": ["6"] } //... ] ``` Some `StandardsFrameworkItems` won't have a `statementCode`, depending on how a given state has published its standards framework. Change the [`GET /academic-standards`](/api-reference/academic-standards/standards-in-a-framework) request's `normalizedStatementType` filter from "Standard Grouping" to "Standard": ```shell cURL theme={null} # Replace YOUR_FRAMEWORK_UUID with the caseIdentifierUUID from Step 2 curl -X GET \ -H "x-api-key: YOUR_API_KEY" \ "https://api.learningcommons.org/knowledge-graph/v0/academic-standards?standardsFrameworkCaseIdentifierUUID=YOUR_FRAMEWORK_UUID&normalizedStatementType=Standard&gradeLevel=6&gradeLevel=7&gradeLevel=8" ``` ```python Python theme={null} import os import requests api_key = os.getenv("API_KEY") base_url = os.getenv("BASE_URL") framework_uuid = "c6487102-d7cb-11e8-824f-0242ac160002" # California Math headers = {"x-api-key": api_key} # Get middle school standards response = requests.get( f"{base_url}/academic-standards", headers=headers, params={ "standardsFrameworkCaseIdentifierUUID": framework_uuid, "normalizedStatementType": "Standard", "gradeLevel": ["6", "7", "8"] } ) result = response.json() standards = result["data"] print(f'✅ Retrieved {len(standards)} standards for California middle school mathematics') for standard in standards[:5]: print(f' {standard["statementCode"]}: {standard["description"][:80]}...') ``` ```javascript JavaScript theme={null} const apiKey = process.env.API_KEY; const baseUrl = process.env.BASE_URL; const frameworkUuid = "c6487102-d7cb-11e8-824f-0242ac160002"; // California Math // Get middle school standards const params = new URLSearchParams({ standardsFrameworkCaseIdentifierUUID: frameworkUuid, normalizedStatementType: "Standard", }); ["6", "7", "8"].forEach((grade) => params.append("gradeLevel", grade)); const response = await fetch(`${baseUrl}/academic-standards?${params}`, { method: "GET", headers: { "x-api-key": apiKey }, }); const result = await response.json(); const standards = result.data; console.log( `✅ Retrieved ${standards.length} standards for California middle school mathematics`, ); standards.slice(0, 5).forEach((s) => { console.log(` ${s.statementCode}: ${s.description.substring(0, 80)}...`); }); ``` Filter on a specific Standard Grouping for more specificity: ```json Response for standards within cluster 8.EE.B theme={null} [ { "caseIdentifierUUID": "5ec25ed1-d7cc-11e8-824f-0242ac160002", "statementCode": "8.EE.B.5", "description": "Graph proportional relationships, interpreting the unit rate...", "normalizedStatementType": "Standard", "gradeLevel": ["8"] } // ... ] ``` Use these results to inform how you tag your educational math content for middle school students in CA. You can also continue exploring by: * Querying different grade levels, subjects, and states * Exploring other [API endpoints](/api-reference/platform-api/overview) ## Related topics Explore standards alignment, planning, crosswalks, curriculum, and assessment workflows. Use progressions to find prerequisites and generate practice content. Walk through a crosswalk comparison tutorial with Jaccard analysis. # License Source: https://docs.learningcommons.org/knowledge-graph/resources/license Licensing for Knowledge Graph code (MIT) and data (CC BY 4.0); attribution and source credits for standards, learning components, and progressions. Knowledge Graph code is licensed under [MIT](https://opensource.org/license/mit) ↗. Knowledge Graph is provided by Learning Commons under the CC BY 4.0 license ([CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.en) ↗). Learning Commons received state standards and written permission under CC BY 4.0 from 1EdTech; learning components under CC BY 4.0 from Achievement Network; and learning progressions under CC0 from Student Achievement Partners ([CC0](https://creativecommons.org/public-domain/cc0/) ↗). # Release notes Source: https://docs.learningcommons.org/knowledge-graph/resources/release-notes Knowledge Graph release notes: v1.13.0 updates state standards frameworks. ### v1.13.0 * Updated the [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) dataset from CGLT data * Added new standards frameworks for Iowa (Social Studies), Maryland (Social Studies), Minnesota (Mathematics), Minnesota (Social Studies), Montana (ELA), Oklahoma (Science), Oregon (Social Science), and South Dakota (ELA) * Updated superseded frameworks to `isCurrent=false` (existing relationships to other entities preserved) * Updated [`adoptionStatus`](/knowledge-graph/schema-reference/standards#standardsframework) for Alabama Science (2023) from "Pending Implementation" to "Adopted" * Fixed [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) data issues * North Dakota (ELA) — Incorrect `statementType` and `normalizedStatementType` for a standard * Ohio (ELA) — Incorrect `statementType` and `normalizedStatementType` for a standard * Montana (Social Studies) — Incorrect `statementType` and `normalizedStatementType` for several standards * Updated `author` and `attributionStatement` for Indiana Mathematics ### v1.12.0 * Added [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions) dataset * Employer-recognized skills progressions for high school students * Sourced from the [Carnegie Foundation for the Advancement of Teaching](https://www.carnegiefoundation.org/) ↗ and [ETS](https://www.ets.org/) ↗’s *Skills Progressions, Vol. 1* * Added [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies) dataset * Competencies for high school students * Sourced from the [XQ Institute](https://xqsuperschool.org/) ↗’s *XQ Competencies* * Updated [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) from CGLT data * Refreshed existing standards frameworks' content * Added new standards frameworks with new UUIDs and `isCurrent=true` New frameworks are not yet aligned with [Learning components](/knowledge-graph/schema-reference/learning-components). Currently, all [learning components](/knowledge-graph/schema-reference/learning-components) → [standards](/knowledge-graph/schema-reference/standards) alignments still reference the old standards. * Deprecated old standards frameworks with `isCurrent=false` (preserved existing relationships) * Removed `isCurrent` from [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) (remains on [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework)) * Updated [`adoptionStatus`](/knowledge-graph/schema-reference/standards#standardsframework) to reflect CGLT values * Updated [`gradeLevel`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) values to match CGLT source values ### v1.11.0 * [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) * Added optional `alternateStatementCode` field for statement codes that are not included in the [CASE specification](https://www.imsglobal.org/activity/case) ↗, but are commonly used by publishers, teachers, and other edtech practitioners * Populated for [Texas Essential Knowledge and Skills (TEKS)](https://tea.texas.gov/curriculum-and-instruction/texas-essential-knowledge-and-skills-teks) ↗ and various other states' standards * [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) and [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) * Updated `author` and `attributionStatement` fields to mention the state * Added `isCurrent` field to indicate whether the record is the most up-to-date version for the state-subject pair ### v1.10.1 * Restored Math [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) between Texas and CCSS standards that were incorrectly removed in v1.9.0 * Updated the corresponding [JSONL file downloads](/knowledge-graph/using-knowledge-graph/local-files#download) * Updated the corresponding [API responses](/api-reference/standards-crosswalks/crosswalks-for-a-standard) If you downloaded the Knowledge Graph JSONL files or queried the standards crosswalks during v1.9.0 or v1.10.0, re-download the files or re-query the endpoints to pick up the restored data. ### v1.10.0 * Updated [ELA Learning Components](/knowledge-graph/datasets/learning-components/ela-learning-components) and [Math Learning Components](/knowledge-graph/datasets/learning-components/math-learning-components) * Updated license and attribution statement values for ELA Learning Components * Removed duplicate Learning Components causing inaccurate Jaccard scores for [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) * Improved [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) dataset quality * Trimmed whitespace from fields * Fixed `inLanguage` and `gradeLevel` fields where they didn't match `ENUM` * Removed duplicate [`hasChild`](/knowledge-graph/schema-reference/standards#haschild) and [`hasReference`](/knowledge-graph/schema-reference/curriculum#hasreference) relationships * Updated [`mutuallyExclusiveWith`](/knowledge-graph/schema-reference/curriculum#mutuallyexclusivewith) relationship to always be bi-directional * Added missing [`Material`](/knowledge-graph/schema-reference/curriculum#material) entities * Fixed [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) data issues * Montana Social Studies — Several standards had `normalizedStatementType` incorrectly set to null * New York Math — One standard had `statementType` and `normalizedStatementType` incorrectly set to null and was missing some Learning Component alignments * Indiana Science — Some standards had `subject` incorrectly set to "Other" #### API updates * Added a boolean `hasChildren` field to [standards](/knowledge-graph/schema-reference/standards) API responses to indicate whether an academic standard has child standards * [`GET /academic-standards`](/api-reference/academic-standards/standards-in-a-framework) * [`GET /academic-standards/{caseIdentifierUUID}`](/api-reference/academic-standards/standard-by-id) * [`GET /academic-standards/{caseIdentifierUUID}/children`](/api-reference/academic-standards/children-of-a-standard) * Clarified descriptions for [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) / Learning Progressions API endpoints * [`GET /academic-standards/{caseIdentifierUUID}/prerequisites`](/api-reference/academic-standards/prerequisites-for-a-standard) — Standards a given standard builds *from* * [`GET /academic-standards/{caseIdentifierUUID}/builds-towards`](/api-reference/academic-standards/standards-a-standard-builds-towards) — Standards a given standard builds *towards* (those it is a prerequisite of) ### v1.9.0 * Aligned [ELA Learning Components](/knowledge-graph/datasets/learning-components/ela-learning-components) to ELA [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) (grades K-2) * CCSS * State standards (Connecticut, Delaware, Illinois, Maryland, Michigan, Mississippi, Nevada, New Hampshire, Vermont, Washington, Washington, D.C., and Wyoming) Learning Components now span both [Math](/knowledge-graph/datasets/learning-components/math-learning-components) and ELA ([ELA Learning Components](/knowledge-graph/datasets/learning-components/ela-learning-components)). ### v1.8.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Alabama, Arkansas, Missouri, North Dakota, Oregon, and Wyoming, with crosswalks to CCSS * Finished aligning [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Texas (grades K–1) #### API updates * [`GET /curriculums/{curriculumId}/dependency-map`](/api-reference/curriculum/dependency-map-for-a-curriculum) - Gets a dependency map (i.e., between [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) entities) for a curriculum ### v1.7.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Georgia, Iowa, Kentucky, Tennessee, and West Virginia, with crosswalks to CCSS * Fixed inconsistent [Learning Component](/knowledge-graph/datasets/learning-components) alignments to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Utah, South Dakota, Mississippi, Idaho, and Ohio * Added a `publisherIdentifier` field to nodes in the [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) dataset that contains the ID originally assigned by Illustrative Mathematics (available in both [file downloads](/knowledge-graph/using-knowledge-graph/local-files#download) and [API responses](/api-reference/curriculum/courses-in-a-curriculum)) ### v1.6.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Kansas * Fixed inconsistent [Learning Component](/knowledge-graph/datasets/learning-components) alignments to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Massachusetts * Fixed the direction of the [`hasDependency`](/knowledge-graph/schema-reference/curriculum#hasdependency) relationship between components in [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) #### API updates * [`GET /academic-standards/search`](/api-reference/academic-standards/search-standards) - Supports semantic search (i.e., search by concept or statement code) and filtering by grade, subject, and statement type * [`GET /learning-components/search`](/api-reference/learning-components/search-learning-components) - Semantic search for Learning Components (i.e., search by description or identifier) #### Learning Commons Platform updates * Create [API keys](https://platform.learningcommons.org/api-keys) ↗ to access our [REST API](/knowledge-graph/using-knowledge-graph/rest-api) and [MCP server](/knowledge-graph/using-knowledge-graph/mcp-server) ### v1.6.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for North Carolina #### API updates * Added endpoints for lessons, activities, and assessments aligned to a specific academic standard * [`GET /academic-standards/{caseIdentifierUUID}/lessons`](/api-reference/academic-standards/lessons-for-a-standard) * [`GET /academic-standards/{caseIdentifierUUID}/activities`](/api-reference/academic-standards/activities-for-a-standard) * [`GET /academic-standards/{caseIdentifierUUID}/assessments`](/api-reference/academic-standards/assessments-for-a-standard) * Added endpoints for [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) * [`GET /courses`](/api-reference/curriculum/courses-in-a-curriculum) * [`GET /courses/{courseId}/scope-and-sequence`](/api-reference/curriculum/scope-and-sequence-for-a-course) * [`GET /lesson-groupings/{groupingId}`](/api-reference/curriculum/lesson-grouping-by-id) * [`GET /lessons/{lessonId}`](/api-reference/curriculum/lesson-by-id) * [`GET /lessons/{lessonId}/activities`](/api-reference/curriculum/activities-in-a-lesson) * [`GET /assessments`](/api-reference/curriculum/assessments-in-a-course) * Added endpoints for [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) aligned to a curriculum's lessons, activities, and assessments * [`GET /lessons/{lessonId}/standards`](/api-reference/curriculum/standards-for-a-lesson) * [`GET /activities/{activityId}/standards`](/api-reference/curriculum/standards-for-an-activity) * [`GET /assessments/{assessmentId}/standards`](/api-reference/curriculum/standards-for-an-assessment) Instructional materials ([`Material`](/knowledge-graph/schema-reference/curriculum#material) entities for lessons, activities, and assessments) are not included. ### v1.5.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Florida, Idaho, Mississippi, Ohio, South Dakota, and Utah ### v1.4.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Massachusetts * Added the [IM® v.360 dataset](/knowledge-graph/datasets/curriculum/im-v360) - Includes IM® v.360 curriculum's scope and sequence ([CC BY-4.0](https://creativecommons.org/licenses/by/4.0/deed.en) ↗ license) * Added [`relevantToStandard`](/knowledge-graph/schema-reference/instructional-guidance#relevanttostandard) relationship to the [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) dataset - Links a [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) to a [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) for CCSS ELA standards ### v1.3.0 * Enable downloading Knowledge Graph data via [JSONL files](/knowledge-graph/using-knowledge-graph/local-files) with UTF-8 encoding (no longer using deprecated flat CSV files) ### v1.2.0 * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Wisconsin * Added [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) to compare state standards to CCSS * Added the [Learner Variability Navigator dataset](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) from [Digital Promise®](https://lvp.digitalpromiseglobal.org/) ↗ (contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ to get access) * Updated attribution statement to include Learning Commons ### v1.1.0 * Added [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Washington, D.C. * Aligned [learning components](/knowledge-graph/datasets/learning-components) to [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) for Louisiana, Montana, Pennsylvania, and Washington, D.C. ## Related topics Report issues or ask questions about a recent release. # Support Source: https://docs.learningcommons.org/knowledge-graph/resources/support Get support for Knowledge Graph: report issues, contact the team, or sign up for early access to curriculum data, APIs, and the MCP server. We want to hear from you. For questions or feedback, please [open an issue](https://github.com/learning-commons-org/knowledge-graph/issues) ↗ or reach out to us at [support@learningcommons.org](mailto:support@learningcommons.org) ↗. # Terms of Use Source: https://docs.learningcommons.org/knowledge-graph/resources/terms-of-use Read the terms of use governing your access to Knowledge Graph data, APIs, and Learning Commons documentation, including licensing and usage rules. These terms are part of [our Terms of Use ↗](https://learningcommons.org/terms-of-use/) and govern your use of our tools, datasets, documentation, and other public resources. Capitalized terms not defined here have the same meanings set out in the Terms of Use. By using any resources in this repository — including datasets, documentation, our tools Knowledge Graph, Evaluators, Agent Skills, or other downloadable assets — you agree to the following: ### 1. Intended Use * These resources are provided for exploratory, research, and other uses permitted under their respective licenses. * They are not intended for high-stakes educational decisions such as formal student evaluation, instructional placement, or grading. ### 2. Licensing & Compliance * Each resource is released under its specified license. * You must review and comply with all terms and conditions in that license, including any attribution or usage limitations described in the accompanying documentation. * Some resources (e.g., individual Evaluators, Agent Skills, datasets, or Knowledge Graph components) may have additional license or usage terms. Review the repository’s README, LICENSE, and related documentation before use. ### 3. Updates & Versioning * Resources may be updated over time to improve accuracy, add features, or correct issues. * Users should check the release information or tags to ensure they are using the latest available version. ### 4. Responsible Use * Use of these resources must comply with all applicable laws and align with our [Community Guidelines ↗](https://learningcommons.org/community-guidelines/). * You must not: * Use the data to promote discrimination, misinformation, or harm * Circumvent safeguards or ignore usage restrictions ### 5. Limitations & Accuracy * Claims of accuracy, safety, fairness, or pedagogical effectiveness should not be made solely on the basis of outputs from these tools. * Human judgment is expected when interpreting results. * Performance may vary depending on factors such as input type, grade level, data format, or technical implementation. See the documentation for any known limitations. # Common relationship properties Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/common-relationship-properties Reference for relationship properties and relationshipType values across Knowledge Graph entities, including edge structure and join behavior. All relationships share a common set of properties. The `relationshipType` property differentiates between relationships for different entities. Check out the other schema reference pages for each entity's supported relationships. | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------- | :---------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content | `String` | 1 | | `ccssLCCount` | Number of [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)s supporting the CCSS standard | `Integer` | 1 | | `connectionType` | Specifies whether the strategy supports or improves the target factor | `String` | 1 | | `dateCreated` | Date the item was created | `Date` | 0..1 | | `dateModified` | Date the item was most recently modified | `Date` | 0..1 | | `description` | Description of the item | `String` | 1 | | `factorCategory` | Category of the target factor | `String` | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `jaccard` | Proportion of shared LCs, calculated as the size of the intersection ÷ size of the union of LC sets; range: (0, 1] | `Float` | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (e.g., hasChild, supports, buildsTowards) | `String` | 1 | | `sharedLCCount` | Number of [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)s supporting both the state and CCSS standard | `Integer` | 1 | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | `String` | 1 | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | `String` | 1 | | `sourceEntityValue` | Identifier of the entity where the relationship originates; represents the starting point of the connection | `String` | 1 | | `stateLCCount` | Number of [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)s supporting the state standard | `Integer` | 1 | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | `String` | 1 | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | `String` | 1 | | `targetEntityValue` | Identifier of the entity the relationship points to; represents the endpoint or destination of the connection | `String` | 1 | **Indicates properties that are only available for [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) and [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) data.** ```json Example relationship between an Activity and StandardsFrameworkItem theme={null} { "type": "relationship", "identifier": "58de2d2a-34b2-512f-a14d-389b8840aa52", "label": "hasEducationalAlignment", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received the scope and sequence of the Illustrative Mathematics 360 curriculum under CC BY-4.0 from Illustrative Mathematics.", "identifier": "58de2d2a-34b2-512f-a14d-389b8840aa52", "curriculumAlignmentType": "addressing", "provider": "Learning Commons", "sourceEntity": "Activity", "sourceEntityKey": "identifier", "alignmentType": "teaches", "author": "Illustrative Mathematics", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "hasEducationalAlignment" }, "source_identifier": "im:3c223476-a9f5-568d-8176-0ee31861723b", "source_labels": ["Activity"], "target_identifier": "827a633a-b88a-5ce9-8a7a-18369c547363", "target_labels": ["StandardsFrameworkItem"] } ``` ## Related topics See entities and relationships grouped by dataset category. Learn how entities, relationships, and UUIDs structure Knowledge Graph datasets. # Curriculum Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/curriculum Reference for Curriculum datasets in Knowledge Graph: courses, lessons, activities, assessments, and materials aligned to the K-12 curriculum ontology. [Schema last updated September 23, 2025.](#schema-release-history) ## Overview Curriculum [entities](#entities) and [relationships](#relationships) are referenced in the [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) dataset. Curriculum data represents standards-aligned lessons and assessments provided by a publisher. Instructional content in a curriculum includes hierarchy and sequencing. Follow these explicit instructional dependencies to analyze how concepts build over time. ## Entities ### `Course` Structured sequence of instructional content, designed to teach specific knowledge or skills over a defined period of time | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `courseCode` | Identifier for the course used by the course provider (e.g. CS101 or 6.001) | `String` | 0..1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics® | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`Array of GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | | `timeRequired` | Approximate or typical time it usually takes to work with or through the content of this work for the typical or target audience | [`Duration`](/knowledge-graph/schema-reference/enums-and-formats#duration) | 0..1 | ```json example.json theme={null} { "type": "node", "identifier": "im:dac57835-073f-52d9-9d63-d6b3b2cb6b55", "labels": ["Course"], "properties": { "dateCreated": "2021-04-30", "timeRequired": "P136D", "license": "https://creativecommons.org/licenses/by/4.0/", "gradeLevel": "[\"2\",\"elementary_school\"]", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received the scope and sequence of the Illustrative Mathematics 360 curriculum under CC BY-4.0 from Illustrative Mathematics.", "educationalUse": "instruction", "lmsLoadingGuidance": "unspecified", "description": "The big ideas in IM Grade 2 include: extending understanding of the base-ten number system;, building fluency with addition and subtraction; using standard units of measure; and describing and analyzing shapes. The materials, particularly units that focus on addition and subtraction, include problem types such as Add To, Take From, Put Together or Take Apart, Compare, Result Unknown, and so on. These problem types are based on common addition and subtraction situations, as outlined in Table 1 of the “Mathematics Glossary” section of the Common Core State Standards (NGA & CCSSO).\n", "identifier": "im:dac57835-073f-52d9-9d63-d6b3b2cb6b55", "provider": "Learning Commons", "name": "Grade 2", "inLanguage": "English", "courseCode": "im360:2", "audience": "[\"Teacher\",\"Student\",\"Family\"]", "author": "Illustrative Mathematics", "academicSubject": "Mathematics", "curriculumLabel": "Course", "publisherIdentifier": "482176" } } ``` ### `LessonGrouping` Set of related [`Lesson`s](#lesson) (naming and level may vary across publishers - e.g., Unit, Module, Chapter) | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `courseCode` | Identifier for the course used by the course provider (e.g. CS101 or 6.001) | `String` | 0..1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `groupLevel` | Position of a lesson grouping in a series or sequence of lesson groupings | `Integer` | 1 | | `groupName` | Lesson grouping name (e.g., Unit, Section, Module) | `String` | 1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `ordinalName` | Label that combines the item's sequence number with descriptive text to indicate its order and context within a larger structure (e.g., 'Lesson 1', 'Chapter 2') | `String` | 0..1 | | `position` | Position of an item in a series or sequence of items | `Integer` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | | `timeRequired` | Approximate or typical time it usually takes to work with or through the content of this work for the typical or target audience | [`Duration`](/knowledge-graph/schema-reference/enums-and-formats#duration) | 0..1 | ### `Lesson` Focused instructional session intended to be completed within a defined timeframe (e.g., class period or session) | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `courseCode` | Identifier for the course used by the course provider (e.g. CS101 or 6.001) | `String` | 0..1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `ordinalName` | Label that combines the item's sequence number with descriptive text to indicate its order and context within a larger structure (e.g., 'Lesson 1', 'Chapter 2') | `String` | 0..1 | | `position` | Position of an item in a series or sequence of items | `Integer` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | | `timeRequired` | Approximate or typical time it usually takes to work with or through the content of this work for the typical or target audience | [`Duration`](/knowledge-graph/schema-reference/enums-and-formats#duration) | 0..1 | ```json example.json theme={null} { "type": "node", "identifier": "im:2a6e3fd1-7429-5a78-9231-2b78c4098873", "labels": ["Lesson"], "properties": { "dateCreated": "2021-04-30", "timeRequired": "PT45M", "gradeLevel": "[\"5\",\"elementary_school\"]", "license": "https://creativecommons.org/licenses/by/4.0/", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received the scope and sequence of the Illustrative Mathematics 360 curriculum under CC BY-4.0 from Illustrative Mathematics.", "educationalUse": "instruction", "lmsLoadingGuidance": "unspecified", "identifier": "im:2a6e3fd1-7429-5a78-9231-2b78c4098873", "position": "4", "provider": "Learning Commons", "isOptional": "false", "name": " Compare Decimals", "inLanguage": "English", "courseCode": "im360:5", "audience": "[\"Teacher\",\"Student\",\"Family\"]", "author": "Illustrative Mathematics", "academicSubject": "Mathematics", "curriculumLabel": "Lesson", "ordinalName": "Lesson 5", "publisherIdentifier": "547489" } } ``` ### `Activity` Discrete instructional task or exercise, designed for students, teachers, or both | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `courseCode` | Identifier for the course used by the course provider (e.g. CS101 or 6.001) | `String` | 0..1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `gradingRequired` | Indicates if the activity must be graded | `Boolean` | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `ordinalName` | Label that combines the item's sequence number with descriptive text to indicate its order and context within a larger structure (e.g., 'Lesson 1', 'Chapter 2') | `String` | 0..1 | | `position` | Position of an item in a series or sequence of items | `Integer` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | | `studentGroupingType` | Describes intended grouping structure for student participation in an activity, indicating how students should collaborate to achieve the educational objectives | [`StudentGroupingTypeENUM`](/knowledge-graph/schema-reference/enums-and-formats#studentgroupingtypeenum) | 0..1 | | `submissionRequired` | Indicates if the activity must be submitted | `Boolean` | 0..1 | | `timeRequired` | Approximate or typical time it usually takes to work with or through the content of this work for the typical or target audience | [`Duration`](/knowledge-graph/schema-reference/enums-and-formats#duration) | 0..1 | ### `Assessment` Evaluation of a student's mastery of knowledge or skills through structured tasks or questions | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `courseCode` | Identifier for the course used by the course provider (e.g. CS101 or 6.001) | `String` | 0..1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `gradingRequired` | Indicates if the activity must be graded | `Boolean` | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | | `studentGroupingType` | Describes intended grouping structure for student participation in an activity, indicating how students should collaborate to achieve the educational objectives | [`StudentGroupingTypeENUM`](/knowledge-graph/schema-reference/enums-and-formats#studentgroupingtypeenum) | 0..1 | | `submissionRequired` | Indicates if the activity must be submitted | `Boolean` | 0..1 | | `variant` | Identifier or label distinguishing different forms of the same assessment, which may vary in item selection, sequencing, or difficulty while maintaining equivalent measurement intent | `String` | 0..1 | ### `Material` Instructional content (e.g., readings, videos, worksheets, images, or digital resources) that supports learning activities | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `content` | Content encoded as HTML | `String` | 1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `materialType` | Classification that indicates the role or purpose of a learning material within the educational context, describing how it is intended to support teaching and learning | [`MaterialTypeENUM`](/knowledge-graph/schema-reference/enums-and-formats#materialtypeenum) | 1 | | `name` | Name of the item | `String` | 0..1 | | `ordinalName` | Label that combines the item's sequence number with descriptive text to indicate its order and context within a larger structure (e.g., 'Lesson 1', 'Chapter 2') | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | ### `ClassroomMaterial` Physical tools, supplies, or resources that support instruction, but do not themselves contain instructional content (e.g., manipulatives, lab equipment, or presentation tools) | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `position` | Position of an item in a series or sequence of items | `Integer` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | ### `GlossaryTerm` Vocabulary or concepts that support comprehension of the instructional content | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `position` | Position of an item in a series or sequence of items | `Integer` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | ### `InstructionalRoutine` Structured and repeatable teaching strategy or pedagogical framework consistently employed to deliver instructional content and engage students | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `audience` | Specifies the intended audience for a learning resource, indicating who the content is designed for or most relevant to | [`EducationalAudienceENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationalaudienceenum) | 1..n | | `author` | Author of content | `String` | 1 | | `curriculumLabel` | Curriculum-specific category; e.g., `"warm-up"` for an introductory activity in Illustrative Mathematics | `String` | 0..1 | | `dateCreated` | Date the item was created | `Datetime` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `educationalUse` | Property classifies the resource based on whether it is used for delivering instruction or assessing student learning | [`EducationalUseENUM`](/knowledge-graph/schema-reference/enums-and-formats#educationaluseenum) | 0..1 | | `gradeLevel` | Specifies the educational grade for which the Curriculum component is intended | [`GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `gradingRequired` | Indicates if the activity must be graded | `Boolean` | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 0..1 | | `isOptional` | Whether the Curriculum element is optional to complete | `Boolean` | 0..1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `lmsLoadingGuidance` | Indicates the vendor's guidance regarding whether this learning resource should be included when loading content into an LMS; is advisory and may be overridden by local implementation policies | [`lmsLoadingGuidanceENUM`](/knowledge-graph/schema-reference/enums-and-formats#lmsloadingguidanceenum) | 0..1 | | `name` | Name of the item | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 0..1 | | `publisherIdentifier` | ID assigned by the original publisher | `String` | 0..1 | ## Relationships Any relationships that relate to the `Material`, `ClassroomMaterial`, `GlossaryTerm`, and `InstructionalRoutine` entities are restricted and require prior approval. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for information about access and eligibility. ### `hasPart` Connects a parent element to its constituent components to organize instructional content | Source entity | Target entity | | :---------------------------------------------- | :---------------------------------------------- | | [`Course`](#course) | [`LessonGrouping`](#lessongrouping) | | [`Course`](#course) | [`Material`](#material) | | [`Lesson`](#lesson) | [`Activity`](#activity) | | [`Lesson`](#lesson) | [`Assessment`](#assessment) | | [`LessonGrouping`](#lessongrouping) | [`Assessment`](#assessment) | | [`LessonGrouping`](#lessongrouping) | [`Lesson`](#lesson) | | [`LessonGrouping`](#lessongrouping) | [`LessonGrouping`](#lessongrouping) | | [`LessonGrouping`](#lessongrouping) | [`Material`](#material) | | [`InstructionalRoutine`](#instructionalroutine) | [`InstructionalRoutine`](#instructionalroutine) | | [`InstructionalRoutine`](#instructionalroutine) | [`Material`](#material) | | [`Activity`](#activity) | [`Material`](#material) | | [`Assessment`](#assessment) | [`Material`](#material) | | [`Lesson`](#lesson) | [`Material`](#material) | ### `hasEducationalAlignment` Specifies the [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) that a curriculum element is intended to teach, assess, or support | Source entity | Target entity | | :---------------------------------- | :--------------------------------------------------------------------------------------------- | | [`Course`](#course) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [`LessonGrouping`](#lessongrouping) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [`Lesson`](#lesson) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [`Activity`](#activity) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [`Assessment`](#assessment) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [`Material`](#material) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | ### `usesRoutine` Connects a curriculum element to one or more [`InstructionalRoutine`](#instructionalroutine) entities | Source entity | Target entity | | :---------------------- | :---------------------------------------------- | | [`Course`](#course) | [`InstructionalRoutine`](#instructionalroutine) | | [`Lesson`](#lesson) | [`InstructionalRoutine`](#instructionalroutine) | | [`Activity`](#activity) | [`InstructionalRoutine`](#instructionalroutine) | ### `uses` Connects a curriculum element to one or more [`ClassroomMaterial`](#classroommaterial) entities | Source entity | Target entity | | :---------------------- | :---------------------------------------- | | [`Lesson`](#lesson) | [`ClassroomMaterial`](#classroommaterial) | | [`Activity`](#activity) | [`ClassroomMaterial`](#classroommaterial) | ### `hasDependency` Connects a curriculum element to one or more prerequisites of the same entity type | Source entity | Target entity | | :---------------------------------- | :---------------------------------- | | [`LessonGrouping`](#lessongrouping) | [`LessonGrouping`](#lessongrouping) | | [`Lesson`](#lesson) | [`Lesson`](#lesson) | | [`Activity`](#activity) | [`Activity`](#activity) | ### `hasReference` Connects a curriculum element to another that it cites as related instructional content | Source entity | Target entity | | :---------------------------------------------- | :---------------------------------- | | [`InstructionalRoutine`](#instructionalroutine) | [`Activity`](#activity) | | [`InstructionalRoutine`](#instructionalroutine) | [`Lesson`](#lesson) | | [`Lesson`](#lesson) | [`Lesson`](#lesson) | | [`Activity`](#activity) | [`Lesson`](#lesson) | | [`Lesson`](#lesson) | [`Activity`](#activity) | | [`Lesson`](#lesson) | [`Assessment`](#assessment) | | [`Assessment`](#assessment) | [`Lesson`](#lesson) | | [`LessonGrouping`](#lessongrouping) | [`Assessment`](#assessment) | | [`Assessment`](#assessment) | [`LessonGrouping`](#lessongrouping) | | [`LessonGrouping`](#lessongrouping) | [`Lesson`](#lesson) | | [`Lesson`](#lesson) | [`LessonGrouping`](#lessongrouping) | ### `references` Connects a [`Lesson`](#lesson) to other instructional content that reinforces or contextualizes the same knowledge in a non-sequential way | Source entity | Target entity | | :------------------ | :------------------------------ | | [`Lesson`](#lesson) | [`Lesson`](#lesson) | | [`Lesson`](#lesson) | [`GlossaryTerm`](#glossaryterm) | ### `mutuallyExclusiveWith` Connects [`Assessment`s](#assessment) that are alternatives and overlap in content or purpose | Source entity | Target entity | | :-------------------------- | :-------------------------- | | [`Assessment`](#assessment) | [`Assessment`](#assessment) | ## Schema release history | Date | Changed | | ------------------ | -------------- | | September 23, 2025 | First release. | ## Related topics Explore coverage, use cases, and download details for the IM® v.360 dataset. Query courses, scope and sequence, lessons, and assessments via the REST API. # Enums and formats Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/enums-and-formats Knowledge Graph enums and formats: AcademicSubjectENUM, JurisdictionENUM, AdoptionStatusENUM, LanguageENUM, GradeLevelENUM, and ISO 8601 durations. Knowledge Graph uses enums and other controlled vocabularies to restrict property values to predefined options with precise meanings. This ensures consistency across all the [entities](/knowledge-graph/understanding-knowledge-graph/core-concepts#entities) and [relationships](/knowledge-graph/understanding-knowledge-graph/core-concepts#relationships) that make up the Knowledge Graph. ## `AcademicSubjectENUM` Academic subject associated with a resource | Value | Description | | :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **English Language Arts** | Encompasses reading, writing, speaking, listening, and language development, including literature, grammar, and vocabulary | | **Mathematics** | Instruction in numbers, operations, algebra, geometry, statistics, probability, functions, and problem-solving at all grade levels | | **Social Studies** | Includes geography, civics, economics, anthropology, psychology, and sociology, focused on human behavior, institutions, and society | | **Science** | Study of the natural and physical world through observation, experimentation, and analysis, including disciplines such as biology, chemistry, physics, earth science, and environmental science | | **Other** | Academic content that does not fit into traditional subject categories, which may include interdisciplinary studies, career and technical education, life skills, or emerging fields | | **Durable Skills** | Transferable skills such as collaboration, communication, and critical thinking that develop across contexts beyond traditional academic subjects | ## `AdoptionStatusENUM` Adoption status of a state standards framework | Term | Definition | | :-------------- | :---------------------------------------------------------------------------- | | **Draft** | In development; not yet finalized or publicly released | | **Proposed** | Shared for public review but not officially adopted | | **Adopted** | Officially released by the issuing body; publicly available | | **Implemented** | Actively adopted and used in practice by schools or districts | | **Retired** | No longer recommended or supported; replaced, obsolete, or withdrawn from use | ## `Duration` Precise representation of years, months, days, hours, minutes, and seconds, encoded using the ISO 8601 standard (PnYnMnDTnHnMnS) | Unit | Format | Example | Meaning | | :------- | :------------- | :------------- | :-------------------------------------------------------------------- | | Years | PnY | P2Y | Period of 2 years | | Months | PnM | P3M | Period of 3 months | | Weeks | PnW | P4W | Period of 4 weeks | | Days | PnD | P5D | Period of 5 days | | Hours | PTnH | PT6H | Period of 6 hours | | Minutes | PTnM | PT30M | Period of 30 minutes | | Seconds | PTnS | PT45S | Period of 45 seconds | | Combined | PnYnMnDTnHnMnS | P1Y2M3DT4H5M6S | Period of 1 year, 2 months, 3 days, 4 hours, 5 minutes, and 6 seconds | ## `EducationalAudienceENUM` Intended audience for an educational resource | Value | Definition | | :---------- | :-------------------------------------------------------------------------------------------------------- | | **Teacher** | For educators preparing for or delivering instruction (e.g., teacher guides, lesson plans, pacing guides) | | **Student** | For learners directly (e.g., student activities, readings, practice problems) | | **Family** | For families or caregivers supporting student learning (e.g., family letters, at-home discussion guides) | ## `EducationalUseENUM` Purpose of an educational resource | Value | Definition | | :-------------- | :------------------------------------------------------------------------------------------------------------------------ | | **Instruction** | Supports learning through direct instruction, guided practice, exploration, discussion, or other instructional strategies | | **Assessment** | Evaluates student understanding, either during the learning process (formative) or after instruction (summative) | ## `GradeLevelENUM` Grade level a resource is intended for | Value | Definition | | :------- | :--------------------------------------------------------- | | **PK** | U.S. Pre-Kindergarten | | **K** | U.S. Kindergarten | | **1** | U.S. 1st Grade | | **2** | U.S. 2nd Grade | | **3** | U.S. 3rd Grade | | **4** | U.S. 4th Grade | | **5** | U.S. 5th Grade | | **6** | U.S. 6th Grade | | **7** | U.S. 7th Grade | | **8** | U.S. 8th Grade | | **9** | U.S. 9th Grade | | **10** | U.S. 10th Grade | | **11** | U.S. 11th Grade | | **12** | U.S. 12th Grade | | **null** | Grade level is unspecified, unknown, or not yet classified | ## `JurisdictionENUM` Jurisdiction a resource belongs to | **Value** | **Definition** | | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Alabama**, **Alaska**, **Arizona**, **Arkansas**, **California**, **Colorado**, **Connecticut**, **Delaware**, **Florida**, **Georgia**, **Hawaii**, **Idaho**, **Illinois**, **Indiana**, **Iowa**, **Kansas**, **Kentucky**, **Louisiana**, **Maine**, **Maryland**, **Massachusetts**, **Michigan**, **Minnesota**, **Mississippi**, **Missouri**, **Montana**, **Nebraska**, **Nevada**, **New Hampshire**, **New Jersey**, **New Mexico**, **New York**, **North Carolina**, **North Dakota**, **Ohio**, **Oklahoma**, **Oregon**, **Pennsylvania**, **Rhode Island**, **South Carolina**, **South Dakota**, **Tennessee**, **Texas**, **Utah**, **Vermont**, **Virginia**, **Washington**, **Washington, D.C.**, **West Virginia**, **Wisconsin**, **Wyoming** | Jurisdiction within the United States of America with its own constitution, laws, and governance structures | | **Multi-State** | Indicates applicability across more than one U.S. state. Examples include CCSS standards for Math and ELA, and the English Language Development Standards Framework dataset. | ## `LanguageENUM` Language a resource is available in | Value | Definition | | :-------- | :---------------------------------------------- | | **en-US** | English as used in the United States of America | | **es-US** | Spanish as used in the United States of America | ## `lmsLoadingGuidanceENUM` Vendor’s guidance for whether or not a resource should be loaded into an LMS | Value | Definition | | :------------------ | :----------------------------------------------------------------------------------- | | **Required** | Essential to load into the LMS | | **Recommended** | Should load into the LMS | | **Optional** | May load into the LMS at the discretion of the school or district | | **Not Recommended** | Advised against LMS inclusion (not prohibited) | | **Unspecified** | No specific guidance regarding LMS inclusion | ## `MaterialTypeENUM` How a material relates to the core curriculum (e.g., primary instructional materials, optional enhancements, and reference resources) | Value | Definition | | :------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Core** | Provide the main instructional material (e.g. Lesson) | | **Supporting** | Are optional and enhance or extend the core content, providing additional practice or enrichment opportunities (e.g., optional reading materials, practice worksheets) | | **Reference** | Provide additional information about the learning resource (e.g., Course guides) or are referenced by the instructional activity (e.g., primary sources, novel studied in a Course, glossary) | ## `NormalizedStatementTypeENUM` Classification of a [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) based on its role in a [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) | Value | Definition | | :-------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Standard** | Normative statement of expected knowledge or skill that instructional materials, activities, or assessments may align to; actionable learning expectations that describe what a student should know or be able to do at a given stage | | **Standard Grouping** | Organizational or structural element in the hierarchy of a standards framework; group related standards under categories such as grade level, domain, strand, or topic; not instructional targets themselves, but help define the framework’s logical and visual structure | | **Other** | Framework elements that do not serve as instructional targets or structural groupings; may include legislative introductions, general requirements, explanatory notes, or other non-hierarchical components that provide policy context, implementation guidance, or metadata | | **null** | Unspecified, unknown, or not yet classified statement type | To assign this value, we began by having human reviewers assign the correct `normalizedStatementType` labels across all Mathematics standards frameworks. These expert-assigned values provided the ground truth dataset, ensuring a reliable benchmark. When we compared large language model (LLM) classifications against this human-labeled set, the models achieved accuracy ranging from the low 80s in detailed evaluations to over 90% across full frameworks, with especially strong results on the “Standard” class. Based on these results, we extended the assignment process to English Language Arts, Science, and Social Studies standards frameworks as well. ## `StudentGroupingTypeENUM` Intended grouping of students when engaging with an activity | Value | Definition | | :-------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Individual** | Designed for students to work independently, without interaction with peers, to complete tasks or solve problems | | **Pair** | Designed for students to work in pairs, fostering one-on-one collaboration, mutual support, and shared problem-solving | | **Small Group** | Designed for students to work in small groups (3–5 members) to engage in cooperative learning, share diverse perspectives, and collaboratively complete tasks | | **Whole Class** | Designed for the entire class to work together as a single group (often led by the teacher) to discuss, analyze, or collaboratively engage in large-scale tasks | ## Related topics See entities and relationships grouped by dataset category. Learn how entities, relationships, and UUIDs structure Knowledge Graph datasets. # Instructional guidance Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/instructional-guidance Schema reference for Instructional guidance entities in Knowledge Graph, including LearnerModel, Factor, and Strategy properties and relationships. [Schema last updated January 28, 2026.](#schema-release-history) ## Overview Instructional guidance [entities](#entities) and [relationships](#relationships) are referenced in the [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) dataset. Instructional guidance models grade- and subject-specific learner profiles, research-backed factors, and instructional strategies. `StandardsFrameworkItem` connection targets are defined in [standards](/knowledge-graph/schema-reference/standards#entities). ## Entities ### `LearnerModel` Grade band and academic subject pair that describes a specific learner profile (e.g., Math 3–6, Literacy 4–6) Each [`LearnerModel`](#learnermodel) has relevant [`Factor`](#factor)s and [`Strategy`](#strategy)s that help contextualize what’s important for student success for that grade and subject. | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content | `String` | 1 | | `content` | Materials that make up a learner model along with additional information (if available) | `String` | 0..1 | | `description` | Description of the learner model | `String` | 0..1 | | `gradeLevel` | Specifies the educational grade for which the curriculum component is intended | [`Array of GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the learner model, either as textual strings or as URL (URI) links | `String` | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `name` | Name of the learner model | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | ### `Factor` Characteristic that influences learning or performance (e.g., Working memory, Algebraic reasoning) | Factor category | Examples | | :-------------- | :---------------------------------------------------------------------- | | **Context** | Background, environment, access to resources, attention, working memory | | **Skills** | Decoding, fluency, algebraic reasoning | | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content | `String` | 1 | | `category` | Grouping for factors within a LearnerModel | `String` | 0..1 | | `citations` | References to research that supports the factor | `Array` | 0..n | | `content` | Materials that make up a factor along with additional information (if available) | `String` | 0..1 | | `description` | Description of the factor | `String` | 0..1 | | `gradeLevel` | Specifies the educational grade for which the curriculum component is intended | [`Array of GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the factor, either as textual strings or as URL (URI) links | `String` | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `name` | Name of the factor | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | ### `Strategy` Instructional practice that supports a variety of [`Factor`](#factor)s and [`LearnerModel`](#learnermodel)s (e.g., *Peer teaching* supports factors like *Math communication* and *Long-term memory*) | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content | `String` | 1 | | `category` | Grouping for strategies within a LearnerModel | `String` | 0..1 | | `citations` | References to research that supports the strategy | `Array` | 0..n | | `content` | Materials that make up a strategy along with additional information (if available) | `String` | 0..1 | | `description` | Description of the strategy | `String` | 0..1 | | `gradeLevel` | Specifies the educational grade for which the curriculum component is intended | [`Array of GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the strategy, either as textual strings or as URL (URI) links | `String` | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `name` | Name of the strategy | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | ## Relationships ### `hasFactor` Connects a [`LearnerModel`](#learnermodel) to a relevant [`Factor`](#factor) (e.g., *Math 3–6* → *Working memory*) | Source node | Target node | | :------------------------------ | :------------------ | | [`LearnerModel`](#learnermodel) | [`Factor`](#factor) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the `hasFactor` relationship, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ### `hasStrategy` Connects a [`LearnerModel`](#learnermodel) to a relevant [`Strategy`](#strategy) | Source node | Target node | | :------------------------------ | :---------------------- | | [`LearnerModel`](#learnermodel) | [`Strategy`](#strategy) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the `hasStrategy` relationship, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ### `interactsWithFactor` Connects [`Factor`](#factor)s that influence each other (e.g., Working memory ↔ Attention) | Source node | Target node | | :------------------ | :------------------ | | [`Factor`](#factor) | [`Factor`](#factor) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the `interactsWithFactor` relationship, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ### `targetsFactor` Connects a [`Strategy`](#strategy) to a [`Factor`](#factor) that it supports or improves (e.g., Peer teaching → Math communication) | Source node | Target node | | :---------------------- | :------------------ | | [`Strategy`](#strategy) | [`Factor`](#factor) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `connectionType` | Specifies whether the strategy supports or improves the target factor | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `factorCategory` | Category of the target factor | | `identifier` | Identifier of the `targetsFactor` relationship, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ### `relevantToStandard` Connects a [`Factor`](#factor) to a related academic standard | Source node | Target node | | :------------------ | :--------------------------------------------------------------------------------------------- | | [`Factor`](#factor) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the `relevantToStandard` relationship, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ## Schema release history | Date | Changed | | ---------------- | -------------------------------------------------------------- | | January 28, 2026 | Added [`relevantToStandard`](#relevanttostandard) relationship | | December 8, 2025 | First release | ## Related topics Explore coverage, use cases, and download details for the Learner Variability Navigator dataset. Connect learner factors to the standards they are relevant to. Pair instructional strategies with curriculum lessons and activities. # Learning components Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/learning-components Reference for Learning components in Knowledge Graph: granular skills and concepts aligned to standards, with support for progressions and content tagging. [Schema last updated May 27, 2026.](#schema-release-history) ## Overview Learning components [entities](#entities) and [relationships](#relationships) are referenced in the [Math learning components](/knowledge-graph/datasets/learning-components/math-learning-components) and [ELA learning components](/knowledge-graph/datasets/learning-components/ela-learning-components) datasets. Learning components are granular skills or concepts that break broad [standards](/knowledge-graph/schema-reference/standards) down into teachable and measurable parts. ## Entities ### `LearningComponent` Single, well-defined skill or concept that students are expected to learn `LearningComponent`s are granular units of learning used to describe instructional intent at the level of a [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson), [`Activity`](/knowledge-graph/schema-reference/curriculum#activity), or [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment). They are aligned to academic standards, support interoperability across curricula, and serve as the foundational building blocks for organizing content, tracking progress, and enabling personalized instruction. | Property | Description | Type | Cardinality | | :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content | `String` | 1 | | `dateCreated` | Date the item was created | `Date` | 0..1 | | `dateModified` | Date the item was most recently modified | `Date` | 0..1 | | `description` | Description of the item | `String` | 1 | | `examples` | Set of illustrative classroom scenarios showing how the skill is demonstrated; present on some Learning Components and not others | `Array` | 0..n | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | ```json Mathematics example theme={null} { "type": "node", "identifier": "0013fbee-3e76-500f-9978-42aa1a65f105", "labels": ["LearningComponent"], "properties": { "dateCreated": "2025-04-01", "license": "https://creativecommons.org/licenses/by/4.0/", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received Learning Components under CC BY-4.0 from Achievement Network.", "dateModified": "2025-04-01", "description": "Use conversions to solve multi-step real-world problems", "identifier": "0013fbee-3e76-500f-9978-42aa1a65f105", "provider": "Learning Commons", "inLanguage": "en-US", "author": "Achievement Network", "academicSubject": "Mathematics" } } ``` ```json ELA example theme={null} { "type": "node", "identifier": "0046446a-0a9b-5ace-92a3-23d4bb158c68", "labels": ["LearningComponent"], "properties": { "dateCreated": "2026-04-01", "license": "https://creativecommons.org/licenses/by/4.0/", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. ELA Learning Components are provided by Learning Commons under CC BY-4.0.", "dateModified": "2026-04-01", "description": "Identify the front cover of a book", "examples": [ "The educator holds up a book closed. The student points to the front cover when asked, \"Can you show me the front of the book?\"" ], "identifier": "0046446a-0a9b-5ace-92a3-23d4bb158c68", "provider": "Learning Commons", "inLanguage": "en-US", "author": "Learning Commons", "academicSubject": "English Language Arts" } } ``` ## Relationships There is no direct relationship between `LearningComponent`s and [Curriculum](/knowledge-graph/schema-reference/curriculum) entities. To connect the 2 schemas, traverse through a shared [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem): * Curriculum entities align to standards through [`hasEducationalAlignment`](/knowledge-graph/schema-reference/curriculum#haseducationalalignment) * Learning components align to standards through [`supports`](#supports) ### `supports` Links a [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) to the [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) that it supports the understanding, mastery, or achievement of | Source node | Target node | | :---------------------------------------- | :--------------------------------------------------------------------------------------------- | | [`LearningComponent`](#learningcomponent) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`supports`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json Mathematics → CCSSM standard example theme={null} { "type": "relationship", "identifier": "5befaad7-ec1d-5229-a71e-a97c6690f578", "label": "supports", "properties": { "dateCreated": "2025-10-21", "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. ELA Learning Components are provided by Learning Commons under CC BY-4.0. Learning Commons received state standards and written permission under CC BY-4.0 from 1EdTech.", "description": "A supports relationship links one entity to another, indicating that the first contributes to the understanding, mastery, or achievement of the goals defined by the second", "dateModified": "2025-10-21", "identifier": "5befaad7-ec1d-5229-a71e-a97c6690f578", "sourceEntity": "LearningComponent", "provider": "Learning Commons", "sourceEntityKey": "identifier", "author": "Achievement Network & Learning Commons", "relationshipType": "supports", "targetEntityKey": "caseIdentifierUUID" }, "source_identifier": "0013fbee-3e76-500f-9978-42aa1a65f105", "source_labels": ["LearningComponent"], "target_identifier": "98d9b463-56bf-5710-9898-971b8a3c5155", "target_labels": ["StandardsFrameworkItem"] } ``` ```json ELA → CCSS ELA standard example theme={null} { "type": "relationship", "identifier": "1945a29a-723d-589f-bd83-af69cf5c1955", "label": "supports", "properties": { "dateCreated": "2026-04-01", "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. ELA Learning Components are provided by Learning Commons under CC BY-4.0.", "description": "A supports relationship links one entity to another, indicating that the first contributes to the understanding, mastery, or achievement of the goals defined by the second", "dateModified": "2026-04-01", "identifier": "1945a29a-723d-589f-bd83-af69cf5c1955", "sourceEntity": "LearningComponent", "provider": "Learning Commons", "sourceEntityKey": "identifier", "author": "Learning Commons", "relationshipType": "supports", "targetEntityKey": "caseIdentifierUUID" }, "source_identifier": "0046446a-0a9b-5ace-92a3-23d4bb158c68", "source_labels": ["LearningComponent"], "target_identifier": "", "target_labels": ["StandardsFrameworkItem"] } ``` ## Schema release history | Date | Changed | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | | May 27, 2026 | Added `examples` as an optional `LearningComponent` property. Added ELA Learning Components (K–2) to the dataset. | | September 23, 2025 | First release with Mathematics support | ## Related topics Explore coverage, use cases, and download details for Math Learning Components. Explore coverage, use cases, and download details for ELA Learning Components. Use Learning Components to analyze cross-state standards alignment. Query learning components by ID, subject, or standard via the REST API. See the standards that learning components support and align to. # Learning progressions Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/learning-progressions Schema reference for Learning progressions relationships in Knowledge Graph, covering buildsTowards and relatesTo properties between standards items. [Schema last updated September 23, 2025.](#schema-release-history) ## Overview Learning progressions [relationships](#relationships) are referenced in the [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) dataset. Learning progressions detail how [standards](/knowledge-graph/schema-reference/standards) build towards and relate to each other. ## Relationships ### `buildsTowards` Indicates that proficiency in one [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) supports the likelihood of success in another [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem), capturing a directional progression without requiring strict prerequisite order | Source node | Target node | | :--------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------- | | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `description` | Description of the item | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`buildsTowards`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json example.json theme={null} { "type": "relationship", "identifier": "23a99f08-73b9-5e2c-a4f6-ac3c0fcad1f8", "label": "buildsTowards", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received learning progressions under CC0 from Student Achievement Partners.", "description": "A buildsTowards relationship indicates that proficiency in one entity supports the likelihood of success in another, capturing a directional progression without requiring strict prerequisite order.", "identifier": "23a99f08-73b9-5e2c-a4f6-ac3c0fcad1f8", "provider": "Learning Commons", "sourceEntity": "StandardsFrameworkItem", "sourceEntityKey": "caseIdentifierUUID", "author": "Student Achievement Partners", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "buildsTowards" }, "source_identifier": "0465e0ad-eaf2-5d3e-999f-fe665744aaf1", "source_labels": ["StandardsFrameworkItem"], "target_identifier": "db51575f-e92e-5a08-904b-66b7b1a5a656", "target_labels": ["StandardsFrameworkItem"] } ``` ### `relatesTo` Connects 2 [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem)s that share a meaningful conceptual or skill-based link without implying sequence or dependency | Source node | Target node | | :--------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------- | | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `description` | Description of the item | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`relatesTo`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json example.json theme={null} { "type": "relationship", "identifier": "56411f45-8a4a-5788-b05f-46a4a8acde9d", "label": "relatesTo", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received learning progressions under CC0 from Student Achievement Partners.", "description": "A relatesTo relationship connects two entities that share a meaningful conceptual or skill-based link without implying sequence or dependency.", "identifier": "56411f45-8a4a-5788-b05f-46a4a8acde9d", "provider": "Learning Commons", "sourceEntity": "StandardsFrameworkItem", "sourceEntityKey": "caseIdentifierUUID", "author": "Student Achievement Partners", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "relatesTo" }, "source_identifier": "0465e0ad-eaf2-5d3e-999f-fe665744aaf1", "source_labels": ["StandardsFrameworkItem"], "target_identifier": "d9be53e8-38b3-51d7-beca-8a7d45657481", "target_labels": ["StandardsFrameworkItem"] } ``` ## Schema release history | Date | Changed | | ------------------ | ------------- | | September 23, 2025 | First release | ## Related topics Explore coverage, use cases, and download details for the Math Coherence Map dataset. Use progressions to find prerequisites and generate practice content. # Overview Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/overview Overview of shared relationship properties across Knowledge Graph edges, including edge structure and how relationships connect entities. Knowledge Graph [entities](/knowledge-graph/understanding-knowledge-graph/core-concepts#entities) connect through [relationships](/knowledge-graph/understanding-knowledge-graph/core-concepts#relationships). Thematically connected entities and relationships are grouped into categories like [standards](/knowledge-graph/schema-reference/standards) and [learning components](/knowledge-graph/schema-reference/learning-components). Diagram of all Knowledge Graph entities and relationships ## Entities by category | Category | Entities | | :------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Standards**](/knowledge-graph/schema-reference/standards) | [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework), [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [**Learning components**](/knowledge-graph/schema-reference/learning-components) | [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) | | [**Curriculum**](/knowledge-graph/schema-reference/curriculum) | [`Course`](/knowledge-graph/schema-reference/curriculum#course), [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping), [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson), [`Activity`](/knowledge-graph/schema-reference/curriculum#activity), [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment), [`Material`](/knowledge-graph/schema-reference/curriculum#material), [`ClassroomMaterial`](/knowledge-graph/schema-reference/curriculum#classroommaterial), [`GlossaryTerm`](/knowledge-graph/schema-reference/curriculum#glossaryterm), [`InstructionalRoutine`](/knowledge-graph/schema-reference/curriculum#instructionalroutine) | | [**Instructional guidance**](/knowledge-graph/schema-reference/instructional-guidance) | [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel), [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor), [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy) | ## Relationships by category All relationships share [a common property set](/knowledge-graph/schema-reference/common-relationship-properties). | Category | Relationships | | :------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Standards**](/knowledge-graph/schema-reference/standards) | [`hasChild`](/knowledge-graph/schema-reference/standards#haschild), [`supports`](/knowledge-graph/schema-reference/standards#supports), [`hasEducationalAlignment`](/knowledge-graph/schema-reference/standards#haseducationalalignment), [`hasStandardAlignment`](/knowledge-graph/schema-reference/standards#hasstandardalignment) | | [**Learning components**](/knowledge-graph/schema-reference/learning-components) | [`supports`](/knowledge-graph/schema-reference/learning-components#supports) | | [**Learning progressions**](/knowledge-graph/schema-reference/learning-progressions) | [`buildsTowards`](/knowledge-graph/schema-reference/learning-progressions#buildstowards), [`relatesTo`](/knowledge-graph/schema-reference/learning-progressions#relatesto) | | [**Curriculum**](/knowledge-graph/schema-reference/curriculum) | [`hasPart`](/knowledge-graph/schema-reference/curriculum#haspart), [`hasEducationalAlignment`](/knowledge-graph/schema-reference/curriculum#haseducationalalignment), [`usesRoutine`](/knowledge-graph/schema-reference/curriculum#usesroutine), [`uses`](/knowledge-graph/schema-reference/curriculum#uses), [`hasDependency`](/knowledge-graph/schema-reference/curriculum#hasdependency), [`hasReference`](/knowledge-graph/schema-reference/curriculum#hasreference), [`references`](/knowledge-graph/schema-reference/curriculum#references), [`mutuallyExclusiveWith`](/knowledge-graph/schema-reference/curriculum#mutuallyexclusivewith) | | [**Instructional guidance**](/knowledge-graph/schema-reference/instructional-guidance) | [`hasFactor`](/knowledge-graph/schema-reference/instructional-guidance#hasfactor), [`hasStrategy`](/knowledge-graph/schema-reference/instructional-guidance#hasstrategy), [`interactsWithFactor`](/knowledge-graph/schema-reference/instructional-guidance#interactswithfactor), [`targetsFactor`](/knowledge-graph/schema-reference/instructional-guidance#targetsfactor), [`relevantToStandard`](/knowledge-graph/schema-reference/instructional-guidance#relevanttostandard) | ## Enums and formats Controlled vocabularies used across the Knowledge Graph are documented in [Enums and formats](/knowledge-graph/schema-reference/enums-and-formats). ## Related topics Learn how entities, relationships, and UUIDs structure Knowledge Graph datasets. Review the shared property set on every Knowledge Graph relationship. Look up controlled vocabularies used across Knowledge Graph entities and relationships. # Standards Source: https://docs.learningcommons.org/knowledge-graph/schema-reference/standards Reference for Standards in Knowledge Graph: StandardsFramework and StandardsFrameworkItem entities, hierarchy relationships, and standards crosswalk alignments. [Schema last updated July 9, 2026.](#schema-release-history) ## Overview Standards [entities](#entities) and [relationships](#relationships) are referenced in the [U.S. academic standards](/knowledge-graph/datasets/us-academic-standards), [Standards crosswalks](/knowledge-graph/datasets/standards-crosswalks), [English Language Development Standards Framework](/knowledge-graph/datasets/standards/english-language-development-standards-framework), [XQ Competencies](/knowledge-graph/datasets/xq-competencies), and [Carnegie Skills Progressions](/knowledge-graph/datasets/carnegie-skills-progressions) datasets. Standards represent the official expectations for student learning for various academic subjects across jurisdictions. Standards crosswalks connect state mathematics and ELA standards to their closest matching Common Core State Standards based on measurable overlap of Learning Components. ## Entities When a state replaces a standards framework, the previous version still remains in the Knowledge Graph for comprehensive querying. | To access | Directions | | :------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Current frameworks | Look for standards frameworks with `isCurrent=true`. | | Standards for current frameworks | First find a current framework to see its related standards.

Filtering on jurisdiction and academic subject alone is NOT sufficient to get the most current standards or to disambiguate between standards belonging to different frameworks. | ### `StandardsFramework` Complete academic standards document published by an official body like a state department of education `StandardsFramework`s serve as the root entity that organizes and contextualizes all standards within a given framework. | Property | Description | Type | Cardinality | | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `adoptionStatus` | Adoption status of a framework within a given jurisdiction or governing body; indicates whether the document has been formally adopted, deprecated, proposed, or otherwise designated for use | [`AdoptionStatusENUM`](/knowledge-graph/schema-reference/enums-and-formats#adoptionstatusenum) | 1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms

State `StandardsFramework`s will include the state. | `String` | 1 | | `author` | Author of content

State `StandardsFramework`s will include the state. | `String` | 1 | | `caseIdentifierURI` | URI referencing the equivalent item in the CASE Network published by 1EdTech | `String` | 1 | | `caseIdentifierUUID` | UUID referencing the equivalent item in the CASE Network published by 1EdTech | `String` | 1 | | `dateCreated` | Date the item was created | `Date` | 0..1 | | `dateModified` | Date the item was most recently modified | `Date` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 1 | | `isCurrent` | Whether this is the most up-to-date `StandardsFramework` for the state-subject pair | `Boolean` | 1 | | `jurisdiction` | Geographic, political, or organizational authority under which a standards framework is published, adopted, or implemented; a jurisdiction typically refers to a state, territory, country, or governing education agency responsible for endorsing or overseeing the framework | [`JurisdictionENUM`](/knowledge-graph/schema-reference/enums-and-formats#jurisdictionenum) | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `name` | Name of the item | `String` | 0..1 | | `notes` | (Optional) Human-readable field that provides additional context, commentary, or clarifying information about a framework, grouping, or standard | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | ```json example.json theme={null} { "type": "node", "identifier": "2ad51889-1547-50f9-b00b-0d986503e5c5", "labels": ["StandardsFramework"], "properties": { "jurisdiction": "North Dakota", "license": "https://creativecommons.org/licenses/by/4.0/", "adoptionStatus": "Implemented", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. North Dakota Mathematics standards provided by North Dakota Department of Public Instruction.", "dateModified": "2024-07-11", "identifier": "2ad51889-1547-50f9-b00b-0d986503e5c5", "provider": "Learning Commons", "name": "2023 North Dakota Mathematics Content Standards", "inLanguage": "en-US", "caseIdentifierUUID": "35e500e6-1f49-11ee-8722-0242ac1f0003", "author": "North Dakota Department of Public Instruction", "caseIdentifierURI": "https://case.nd.gov/uri/35e500e6-1f49-11ee-8722-0242ac1f0003", "academicSubject": "Mathematics", "isCurrent": true } } ``` ### `StandardsFrameworkItem` Individual statement or structural element within a standards framework `StandardsFrameworkItem`s may be normative statements (e.g., a standard that specifies what students should know or be able to do) or organizational groupings (e.g., strands, clusters). | Property | Description | Type | Cardinality | | :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------- | :---------- | | `academicSubject` | Academic subject | [`AcademicSubjectENUM`](/knowledge-graph/schema-reference/enums-and-formats#academicsubjectenum) | 1 | | `alternateStatementCode` | Alternate statement code commonly used by publishers, teachers, and other edtech practitioners; currently populated for [Texas Essential Knowledge and Skills (TEKS)](https://tea.texas.gov/curriculum-and-instruction/texas-essential-knowledge-and-skills-teks) and various other states' standards | `String` | 0..1 | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content’s license (e.g., Creative Commons BY); specifies how the creator should be attributed in accordance with the license terms | `String` | 1 | | `author` | Author of content

State `StandardsFrameworkItem`s will include the state. | `String` | 1 | | `caseIdentifierURI` | URI referencing the equivalent item in the CASE Network published by 1EdTech | `String` | 1 | | `caseIdentifierUUID` | UUID referencing the equivalent item in the CASE Network published by 1EdTech | `String` | 1 | | `dateCreated` | Date the item was created | `Date` | 0..1 | | `dateModified` | Date the item was most recently modified | `Date` | 0..1 | | `description` | Description of the item | `String` | 0..1 | | `gradeLevel` | Specifies the educational grade for which the curriculum component is intended | [Array of `GradeLevelENUM`](/knowledge-graph/schema-reference/enums-and-formats#gradelevelenum) | 0..n | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | `String` | 1 | | `inLanguage` | Language of the content | [`LanguageENUM`](/knowledge-graph/schema-reference/enums-and-formats#languageenum) | 1 | | `jurisdiction` | Geographic, political, or organizational authority under which a standards framework item is published, adopted, or implemented; typically refers to a state, territory, country, or governing education agency responsible for endorsing or overseeing the framework | [`JurisdictionENUM`](/knowledge-graph/schema-reference/enums-and-formats#jurisdictionenum) | 1 | | `license` | License document that applies to this content, typically indicated by URL | `String` | 1 | | `normalizedStatementType` | Normalized value that describes the broad functional role of a `StandardsFrameworkItem` within a standards framework; distinguishes between instructional targets, structural elements, and supportive or contextual content, regardless of how those elements are labeled or structured in individual state or national standards | [`NormalizedStatementTypeENUM`](/knowledge-graph/schema-reference/enums-and-formats#normalizedstatementtypeenum) | 1 | | `notes` | Optional, human-readable field that provides additional context, commentary, or clarifying information about a framework, grouping, or standard | `String` | 0..1 | | `provider` | Service provider, service operator, or service performer | `String` | 1 | | `statementCode` | Short, human-readable code that uniquely identifies a StandardsFrameworkItem within its immediate context; typically used to refer to standards or elements in official documents, curriculum materials, or assessment systems; the statementCode is often alphanumeric (e.g., "3.NF.A.1", "A.1B", "MP1") and reflects the framework’s internal coding scheme | `String` | 0..1 | | `statementType` | Framework-specific classification that describes the local role or label of a StandardsFrameworkItem as defined by its source framework; unlike the normalized frameworkItemType, which generalizes across systems, statementType preserves the vocabulary and taxonomy used in the originating standards (e.g., “Domain”, “Cluster”, “Strand”, “Benchmark”, “Practice Standard”) | `String` | 0..1 | ```json example.json theme={null} { "type": "node", "identifier": "b1c6207f-15e0-56a4-97f2-ebe9824395d0", "labels": ["StandardsFrameworkItem"], "properties": { "jurisdiction": "North Carolina", "license": "https://creativecommons.org/licenses/by/4.0/", "gradeLevel": "[\"1\"]", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. North Carolina Social Studies standards provided by North Carolina Department of Public Instruction available at https://www.dpi.nc.gov/districts-schools/classroom-resources/office-teaching-and-learning/standard-course-study/social-studies/standard-course-study-supporting-resources.", "normalizedStatementType": "Standard Grouping", "description": "Communicating Ideas", "dateModified": "2023-05-05", "identifier": "b1c6207f-15e0-56a4-97f2-ebe9824395d0", "provider": "Learning Commons", "inLanguage": "en-US", "caseIdentifierUUID": "00355e2b-623a-40c9-9425-03482290b790", "author": "North Carolina Department of Public Instruction", "academicSubject": "Social Studies", "caseIdentifierURI": "https://satchelcommons.com/ims/case/v1p0/CFItems/00355e2b-623a-40c9-9425-03482290b790", "statementType": "Category", "isCurrent": true } } ``` ## Relationships ### `hasChild` Indicates that one entity serves as the parent of another | Source node | Target node | | :-------------------------------------------------- | :-------------------------------------------------- | | [`StandardsFramework`](#standardsframework) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`StandardsFrameworkItem`](#standardsframeworkitem) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`hasChild`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json example.json theme={null} { "type": "relationship", "identifier": "d4aea202-d7cd-11e8-824f-0242ac160002", "label": "hasChild", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received state standards and written permission under CC BY-4.0 from 1EdTech.", "dateModified": "2018-10-24", "description": "A hasChild relationship indicates that one entity serves as the parent of another, representing a hierarchical connection in which the target entity is a direct child of the source entity", "identifier": "d4aea202-d7cd-11e8-824f-0242ac160002", "provider": "Learning Commons", "sourceEntity": "StandardsFramework", "sourceEntityKey": "caseIdentifierUUID", "author": "1EdTech", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "hasChild" }, "source_identifier": "e415efd0-4d66-5110-a399-7fe0045c3e32", "source_labels": ["StandardsFramework"], "target_identifier": "5229a150-dfb7-5990-bd84-36253a849b7a", "target_labels": ["StandardsFrameworkItem"] } ``` ```json example.json theme={null} { "type": "relationship", "identifier": "60a14513-a156-4f61-a435-fcc078f6369d", "label": "hasChild", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received state standards and written permission under CC BY-4.0 from 1EdTech.", "dateModified": "2023-05-05", "description": "A hasChild relationship indicates that one entity serves as the parent of another, representing a hierarchical connection in which the target entity is a direct child of the source entity", "identifier": "60a14513-a156-4f61-a435-fcc078f6369d", "provider": "Learning Commons", "sourceEntity": "StandardsFrameworkItem", "sourceEntityKey": "caseIdentifierUUID", "author": "1EdTech", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "hasChild" }, "source_identifier": "3f4aafa4-8e59-5df8-8804-a8ff63c30e35", "source_labels": ["StandardsFrameworkItem"], "target_identifier": "f2056895-8538-53d2-8067-21474e0bc5db", "target_labels": ["StandardsFrameworkItem"] } ``` ### `supports` Links a [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) to the [`StandardsFrameworkItem`](#standardsframeworkitem) that it supports the understanding, mastery, or achievement of | Source node | Target node | | :--------------------------------------------------------------------------------------------- | :-------------------------------------------------- | | [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | Property | Description | | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `dateCreated` | Date the item was created | | `dateModified` | Date the item was most recently modified | | `description` | Description of the item | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`supports`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json example.json theme={null} { "type": "relationship", "identifier": "f0859810-b725-50cd-93df-8020f4fddb6d", "label": "supports", "properties": { "dateCreated": "2025-10-21", "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received learning components under CC BY-4.0 from Achievement Network.", "description": "A supports relationship links one entity to another, indicating that the first contributes to the understanding, mastery, or achievement of the goals defined by the second", "dateModified": "2025-10-21", "identifier": "f0859810-b725-50cd-93df-8020f4fddb6d", "sourceEntity": "LearningComponent", "provider": "Learning Commons", "sourceEntityKey": "identifier", "author": "Achievement Network & Learning Commons", "relationshipType": "supports", "targetEntityKey": "caseIdentifierUUID" }, "source_identifier": "0013fbee-3e76-500f-9978-42aa1a65f105", "source_labels": ["LearningComponent"], "target_identifier": "c4b66a26-f3cb-5a52-a982-4d11af78549a", "target_labels": ["StandardsFrameworkItem"] } ``` ### `hasEducationalAlignment` Connects a curriculum entity to one or more [`StandardsFrameworkItem`](#standardsframeworkitem) entities that it intends to teach, assess, or support | Source node | Target node | | :------------------------------------------------------------------------------ | :-------------------------------------------------- | | [`Course`](/knowledge-graph/schema-reference/curriculum#course) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`Activity`](/knowledge-graph/schema-reference/curriculum#activity) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | [`Material`](/knowledge-graph/schema-reference/curriculum#material) | [`StandardsFrameworkItem`](#standardsframeworkitem) | | Property | Description | | :------------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------- | | `alignmentType` | Specifies the instructional role of the alignment (e.g., `teaches`, `assesses`) | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `curriculumAlignmentType` | Specifies how the source curriculum element relates to the target standard (e.g., `building_on`, `addressing`) | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links | | `license` | License document that applies to this content, typically indicated by URL | | `provider` | Service provider, service operator, or service performer | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`hasEducationalAlignment`) | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset | ```json example.json theme={null} { "type": "relationship", "identifier": "c770869c-3e19-5fbb-bcb1-a0469eb2eb6e", "label": "hasEducationalAlignment", "properties": { "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license. Learning Commons received the scope and sequence of the Illustrative Mathematics 360 curriculum under CC BY-4.0 from Illustrative Mathematics.", "identifier": "c770869c-3e19-5fbb-bcb1-a0469eb2eb6e", "curriculumAlignmentType": "building_on", "provider": "Learning Commons", "sourceEntity": "Course", "sourceEntityKey": "identifier", "alignmentType": "teaches", "author": "Illustrative Mathematics", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "hasEducationalAlignment" }, "source_identifier": "im:f18ee2b2-6b46-5c68-82d9-4b54f85a9be9", "source_labels": ["Course"], "target_identifier": "64cb2ac3-6f8d-55f5-bbae-6e4de98768e3", "target_labels": ["StandardsFrameworkItem"] } ``` ### `hasStandardAlignment` Connects a state standard to a CCSS standard when the 2 are supported by overlapping sets of [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent)s This relationship does not imply sequence, dependency, or pedagogical progression – only the degree of shared content between the 2 standards. Direction is always state → CCSS (not state → state). | Source node | Target node | | :------------------------------------------------------------------- | :------------------------------------------------------------------ | | [`StandardsFrameworkItem`](#standardsframeworkitem) (state standard) | [`StandardsFrameworkItem`](#standardsframeworkitem) (CCSS standard) | | Property | Description | | :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `attributionStatement` | Textual credit that acknowledges the source or creator of a work, included when required by the content's license (e.g., Creative Commons BY) | | `author` | Author of this content | | `ccssLCCount` | Number of Learning Components supporting the CCSS standard. | | `dateCreated` | Date the item was created. | | `dateModified` | Date the item was most recently modified. | | `description` | A hasStandardAlignment relationship connects a State standard to a CCSS standard when the two are supported by overlapping sets of Learning Components. The relationship indicates an evidence-based crosswalk derived from measurable overlap of deconstructed skills, expressed through properties such as jaccard and LC counts. It does not imply sequence, dependency, or pedagogical progression, only the degree of shared content between the two standards. | | `identifier` | Identifier of the item, either as textual strings or as URL (URI) links. | | `jaccard` | Proportion of shared Learning Components between state and CCSS standards (0 \< Jaccard score ≤ 1) - See [Understanding the Jaccard score](#understanding-the-jaccard-score) | | `license` | License document that applies to this content, typically indicated by URL. | | `provider` | Service provider, service operator, or service performer. | | `relationshipType` | Normalized value that defines the semantic meaning of the connection between the source and target entities (`hasStandardAlignment`). | | `sharedLCCount` | Number of Learning Components shared by both standards. | | `sourceEntity` | Type of entity from which the relationship originates; specifies the class or category of the starting node in the connection. | | `sourceEntityKey` | Name of the property within the source entity that contains its unique identifier; used to locate and reference the entity in the dataset. | | `stateLCCount` | Number of Learning Components supporting the state standard. | | `targetEntity` | Type of entity to which the relationship points; specifies the class or category of the ending node in the connection. | | `targetEntityKey` | Name of the property within the target entity that contains its unique identifier; used to locate and reference the entity in the dataset. | ```json example.json theme={null} { "type": "relationship", "identifier": "3edc451c-392b-50ad-addd-d6b76ab7ab49", "label": "hasStandardAlignment", "properties": { "dateCreated": "2026-01-02", "license": "https://creativecommons.org/licenses/by/4.0/", "targetEntity": "StandardsFrameworkItem", "attributionStatement": "Knowledge Graph is provided by Learning Commons under the CC BY-4.0 license.", "description": "A hasStandardAlignment relationship connects a State standard to a CCSS standard when the two are supported by overlapping sets of Learning Components. The relationship indicates an evidence-based crosswalk derived from measurable overlap of deconstructed skills, expressed through properties such as jaccard and LC counts. It does not imply sequence, dependency, or pedagogical progression, only the degree of shared content between the two standards.", "dateModified": "2026-01-02", "identifier": "3edc451c-392b-50ad-addd-d6b76ab7ab49", "stateLCCount": "2", "provider": "Learning Commons", "sourceEntity": "StandardsFrameworkItem", "sharedLCCount": "2", "sourceEntityKey": "caseIdentifierUUID", "ccssLCCount": "2", "author": "Learning Commons", "jaccard": "1.0", "targetEntityKey": "caseIdentifierUUID", "relationshipType": "hasStandardAlignment" }, "source_identifier": "20d6435a-4b7f-53b7-abcc-cb61dcd36679", "source_labels": ["StandardsFrameworkItem"], "target_identifier": "74721dc3-d49c-5f16-804c-4cb07fca6ed6", "target_labels": ["StandardsFrameworkItem"] } ``` ## Understanding the Jaccard score A Jaccard score measures the level of similarity between 2 sets. It is scored on a scale of 0.0 to 1.0 – 0.0 represents zero overlap and 1.0 represents complete overlap. In the context of the Knowledge Graph, we use the Jaccard score to measure how similar a state standard's Learning Components are to a CCSS standard's Learning Components: **Jaccard score** = Shared Learning Components / Total unique Learning Components **Example**: If a state standard has 5 Learning Components, a CCSSM standard has 6, and they share 4 of them, their Jaccard score would be `4 / (5 + 6 − 4) = 0.57` i.e., about 57% of these standards' underlying skills overlap Only standards with at least one shared Learning Component have a Jaccard score. ## Schema release history | Date | Changed | | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | July 9, 2026 |
  • Added optional `alternateStatementCode` field to `StandardsFrameworkItem`
  • Added `isCurrent` field to `StandardsFramework` and `StandardsFrameworkItem` records
  • Include the state in state `StandardsFramework` and `StandardsFrameworkItem` records' `author` and `attributionStatement` fields
| | September 23, 2025 | First release of Standards entities/relationships and Standards crosswalks `hasStandardAlignment` relationship | ## Related topics Explore coverage, use cases, and download details for the U.S. academic standards dataset. Explore coverage, use cases, and download details for the Standards Crosswalks dataset. Explore coverage, use cases, and download details for the WIDA English Language Development Standards Framework dataset. Query frameworks and standards in a step-by-step tutorial. Walk through a crosswalk comparison tutorial with Jaccard analysis. Query standards by ID, search by statement code, and retrieve related content via the REST API. Find aligned standards across frameworks with similarity metrics via the REST API. # Core concepts Source: https://docs.learningcommons.org/knowledge-graph/understanding-knowledge-graph/core-concepts Learn how Knowledge Graph is built from entities and relationships with UUIDs, and how academic standards and curriculum datasets connect. ## How Knowledge Graph is structured | Concept | Definition | | :--------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Entities](#entities)

| Each entity (or node) represents a distinct concept in the domain, such as an academic standard or learning component. These entities define the core elements of the dataset. | |

[Relationships](#relationships)

| Each relationship (or edge) represents a directed connection between two entities (or nodes). These relationships define how entities relate to one another within the graph.

Relationships are expressed as a triple:
  • Source entity's UUID
  • Relationship UUID
  • Target entity's UUID
| |

[UUID](#uuid)

| Every entity and relationship carries a UUID — these UUIDs link entities together in relationships. Conceptually, this is similar to how foreign keys are used to `JOIN` tables in a relational database.

UUIDs make it easy to deterministically join files, reference entities, and preserve links across datasets. It makes connections explicit without relying on schema-level constraints and avoids tight coupling to any one database system. Some UUIDs come from external sources such as the [CASE Network](https://casenetwork.1edtech.org/) ↗, which ensures interoperability. | |

[Dataset](#dataset)

| Thematic collection of related [entities](#entities) and [relationships](#relationships) that cover a specific educational domain, such as [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) or [Math learning components](/knowledge-graph/datasets/learning-components/math-learning-components)

Datasets share a unified schema and can reference entities across one another (e.g., learning components align to specific academic standards). | ## What Knowledge Graph contains Knowledge Graph is organized into thematic [datasets](/knowledge-graph/datasets). ### Standards The [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards) dataset represents official learning expectations as a hierarchy. The [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) dataset connects state standards to their closest matching CCSS standards. It measures how many [learning components](#learning-component) various [academic standards](#academic-standard) have in common in order to calculate a similarity score. | Concept | Definition | | :----------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Standards frameworks](#standards-frameworks)

| Complete academic standards document published by an official body, such as a state department of education (e.g., *2023 North Dakota Mathematics Content Standards*); modeled as [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework) entities

Each standards framework serves as the root node that organizes all standards groups and individual academic standards within a given jurisdiction and subject. | |

[Standards groups](#standards-groups)

| Organizational groupings within a standards framework – i.e., domains, clusters, strands, or grade bands (e.g., *Operations and Algebraic Thinking* or *Number & Operations—Fractions*); modeled as [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) entities with a `normalizedStatementType` of **Standard Grouping** | |

[Academic standard](#academic-standard)

| Individual statement that specifies what students should know or be able to do at a given grade level (e.g., *3.NF.A.1*); modeled as [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) entities

Academic standards often connect to other datasets — e.g., they're [supported by learning components](/knowledge-graph/schema-reference/standards#supports) and [aligned with curriculum](/knowledge-graph/schema-reference/standards#haseducationalalignment). | | Concept | Definition | | :------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Standard alignment](#standard-alignment)

| An evidence-based match between a state academic standard and a Common Core standard based on shared Learning Components (e.g., *NY 3.NF.1* → *3.NF.A.1*).

Modeled as [`hasStandardAlignment`](/knowledge-graph/schema-reference/standards#hasstandardalignment) relationships. Similarity is expressed with a Jaccard score and Learning Component counts — not as sequence or dependency. | |

[Jaccard score](#jaccard-score)

| A similarity score from 0.0 to 1.0 that measures how much a state standard and a Common Core standard overlap in Learning Components — 0.0 means no overlap and 1.0 means complete overlap.

Calculated as shared Learning Components ÷ total unique Learning Components, and stored as the `jaccard` property on [`hasStandardAlignment`](/knowledge-graph/schema-reference/standards#hasstandardalignment) relationships. See [Understanding the Jaccard score](/knowledge-graph/schema-reference/standards#understanding-the-jaccard-score). | ### Learning components The [Math Learning Components](/knowledge-graph/datasets/learning-components/math-learning-components) and [ELA Learning Components](/knowledge-graph/datasets/learning-components/ela-learning-components) datasets represent granular skills or individual concepts that operate at the instructional level. They break broad [academic standards](#academic-standard) down into measurable, teachable parts. | Concept | Definition | | :------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Learning component](#learning-component)

| Single, well-defined skill or concept that students are expected to learn (e.g., *Use place value to add two two-digit numbers*); modeled as [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) entities

Learning components [`support`](/knowledge-graph/schema-reference/learning-components#supports) one or more [academic standards](#academic-standard). | ### Learning progressions The [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) dataset represents how students traverse learning paths to develop understanding over time. It connects [academic standards](#academic-standard) through directional [`buildsTowards`](/knowledge-graph/schema-reference/learning-progressions#buildstowards) relationships. | Concept | Definition | | :---------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Prerequisite standard](#prerequisite-standard)

| An academic standard whose proficiency supports the likelihood of success in a later standard (e.g., *3.OA.A.1* is a prerequisite for *4.NBT.B.5*).

In a [`buildsTowards`](/knowledge-graph/schema-reference/learning-progressions#buildstowards) relationship, this is the source [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem). | |

[Successor standard](#standard-that-a-standard-builds-towards)

| An academic standard that students are progressing toward after gaining proficiency in an earlier standard (e.g., *4.NBT.B.5* is a standard that *3.OA.A.1* builds towards).

In a [`buildsTowards`](/knowledge-graph/schema-reference/learning-progressions#buildstowards) relationship, this is the target [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem). | ### Curriculum The [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) dataset contains curriculum scope and sequence. In the future, it will also include instructional (e.g., [lessons](#lesson), [activities](#activity), [materials](#material)) and [assessment](#assessment) materials as structured metadata. Any curriculum entity can connect to an academic standard through the [`hasEducationalAlignment`](/knowledge-graph/schema-reference/standards#haseducationalalignment) relationship (e.g., a `Lesson` may point to a `StandardsFrameworkItem` such as `3.NF.A.1` with `alignmentType: teaches`, indicating that the lesson teaches that standard). | Concept | Definition | | :------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

[Course](#course)

| Structured sequence of instructional content designed to teach specific skills or knowledge over a defined period (e.g., *Illustrative Mathematics® Grade 2*); modeled as [`Course`](/knowledge-graph/schema-reference/curriculum#course) entities | |

[Lesson grouping](#lesson-grouping)

| Grouping of lessons within a course, such as a unit, module, or section (e.g., *Unit 3: Adding and Subtracting within 100*); modeled as [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping) entities | |

[Lesson](#lesson)

| Single teachable unit within a lesson grouping, typically covering 1 class session and made up of one or more activities; modeled as [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson) entities | |

[Activity](#activity)

| Smallest instructional unit (e.g., warm-up, task, exit ticket, or discussion) that a teacher or student engages with inside a lesson; modeled as [`Activity`](/knowledge-graph/schema-reference/curriculum#activity) entities | |

[Assessment](#assessment)

| Evaluation of a student's mastery of knowledge, skills, or competencies through structured tasks or questions; modeled as [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment) entities | |

[Material](#material)

| Instructional content (e.g., readings, videos, worksheets, images, or digital resources) that supports learning activities; modeled as [`Material`](/knowledge-graph/schema-reference/curriculum#material) entities | ### Instructional guidance The [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) dataset connects student context and learning goals to research-backed instructional practices. | Concept | Definition | | :--------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | |

[Learner model](#learner-model)

| Grade band and academic subject pair that describes a specific learner profile (e.g., *Math 3–6* or *Literacy 4–6*); modeled as [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel) entities

Each learner model has relevant [factors](#factor) and [strategies](#strategy) that help contextualize what’s important for student success for that grade and subject. | |

[Factor](#factor)

| Research-backed characteristic that influences learning or performance (e.g., *Working memory* or *Algebraic reasoning*); modeled as [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor) entities

Factors can [`interact with`](/knowledge-graph/schema-reference/instructional-guidance#interactswithfactor) other factors and may be [`relevant to`](/knowledge-graph/schema-reference/instructional-guidance#relevanttostandard) specific [academic standards](#academic-standard). | |

[Strategy](#strategy)

| Instructional practice that supports learning for a variety of [factors](#factor) and [learner models](#learner-model) (e.g., *Peer teaching*); modeled as [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy) entities

Strategies [`target`](/knowledge-graph/schema-reference/instructional-guidance#targetsfactor) one or more factors they support or improve. | ## Related topics Review entities, relationships, and property definitions for Academic Standards. Review entities, relationships, and property definitions for Learning Components. Review entities, relationships, and property definitions for Learning Progressions. Review entities, relationships, and property definitions for Curriculum. Review entities, relationships, and property definitions for Instructional guidance. # Introduction Source: https://docs.learningcommons.org/knowledge-graph/understanding-knowledge-graph/introduction Learn what Knowledge Graph is and how its structured datasets connect academic standards, curricula, and learning science for edtech developers. Knowledge Graph data, tutorials, and license details live in the [`knowledge-graph`](https://github.com/learning-commons-org/knowledge-graph) ↗ GitHub repository. ## What Knowledge Graph does Knowledge Graph provides a structured collection of enriched educational datasets that connects academic standards, curricula, and learning science data. It standardizes high-quality datasets with a unified schema, allowing edtech developers to focus on building AI-powered educational tools. | Schema | Description | Datasets | | :------------------------------------------------------------------------------------- | :---------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Standards**](/knowledge-graph/schema-reference/standards) | Hierarchical structures of state or national learning goals |
  • [U.S. academic standards](/knowledge-graph/datasets/standards/us-academic-standards)
  • [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks)
  • [English Language Development Standards Framework](/knowledge-graph/datasets/standards/english-language-development-standards-framework)
  • [XQ Competencies](/knowledge-graph/datasets/standards/xq-competencies)
  • [Carnegie Skills Progressions](/knowledge-graph/datasets/standards/carnegie-skills-progressions)
| | [**Learning components**](/knowledge-graph/schema-reference/learning-components) | Standards broken down into concrete skills or concepts |
  • [Math learning components](/knowledge-graph/datasets/learning-components/math-learning-components)
  • [ELA learning components](/knowledge-graph/datasets/learning-components/ela-learning-components)
| | [**Learning progressions**](/knowledge-graph/schema-reference/learning-progressions) | Logical and usually sequential ordering of learning targets | [Math Coherence Map](/knowledge-graph/datasets/learning-progressions/math-coherence-map) | | [**Curriculum**](/knowledge-graph/schema-reference/curriculum) | Lessons, activities, materials, and assessments from publishers | [IM® v.360](/knowledge-graph/datasets/curriculum/im-v360) | | [**Instructional guidance**](/knowledge-graph/schema-reference/instructional-guidance) | Learner factors and strategies that connect student context to teaching | [Learner Variability Navigator](/knowledge-graph/datasets/instructional-guidance/learner-variability-navigator) | Knowledge Graph datasets are modeled as graphs, using [entities](./core-concepts#entities) (the elements in the dataset) and [relationships](./core-concepts#relationships) (how these elements are connected). Explore [Use cases](/knowledge-graph/understanding-knowledge-graph/use-cases) for Knowledge Graph when aligning standards, planning instructional content, or comparing academic standards across state lines. ## How to access Knowledge Graph Knowledge Graph is accessible in a variety of ways and is designed to be database-neutral, lightweight, and interoperable. The local files in particular can be used across graph databases, relational systems, in-memory tools, and AI pipelines without requiring any specialized infrastructure. | Access method | When to use | | :------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Local files**](/knowledge-graph/using-knowledge-graph/local-files) | For offline access, custom processing, or complex queries across graph databases, relational systems, in-memory tools, and AI pipelines. Preserves the structure of entities and relationships, and supports both deterministic joins and AI workflows like embeddings or RAG. | | [**REST API**](/knowledge-graph/using-knowledge-graph/rest-api) | For real-time programmatic access to data in an application | | [**MCP server**](/knowledge-graph/using-knowledge-graph/mcp-server) | For using natively with an LLM | | [**Agent plugins**](/knowledge-graph/using-knowledge-graph/agent-plugins) | Access Knowledge Graph directly from ChatGPT or Claude | We are continuing to expand these access patterns. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ to request other methods that would be useful for your workflows. ## Related topics Explore standards alignment, planning, crosswalks, curriculum, and assessment workflows. Learn how entities, relationships, and UUIDs structure Knowledge Graph datasets. Get started with the REST API, MCP server, or downloadable JSONL files. # Use cases Source: https://docs.learningcommons.org/knowledge-graph/understanding-knowledge-graph/use-cases See common Knowledge Graph use cases, from aligning content to standards and planning instruction to comparing state standards and personalizing practice. These are several common ways that edtech teams use Knowledge Graph data in product development and instructional workflows. | Use case | Description | Examples | | :--------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Align content to standards** | Create content rooted in [standards](/knowledge-graph/schema-reference/standards) and learner competencies across subjects. | Replace fragmented infrastructure with a single, trusted source of standards data:
  • Populate a standards menu (i.e., 50 states across subjects)
  • Use standards as context when generating AI outputs
  • Integrate standards data with your CMS
| | **Plan instructional content** | Use dependencies ([learning progressions](/knowledge-graph/schema-reference/learning-progressions)) and granular skills ([learning components](/knowledge-graph/schema-reference/learning-components)) to inform instructional content and plans. |
  • Group students more effectively by looking at the skills they've mastered
  • Give each student their own instance of a knowledge model graph, with a score for each node (Learning Component)
  • Build a teacher's dashboard that gives grounded AI recommendations on lesson plans and identifies gaps in prerequisite skills
  • Give more precise feedback
| | **Compare standards across states** | Use [U.S. academic standards crosswalks](/knowledge-graph/datasets/standards/us-academic-standards-crosswalks) to adapt content aligned to a CCSSM standard to a state standard. | Outsource the burden of managing standards across states:
  • Align content across all states you serve
  • Reduce maintenance burden on internal systems
  • Share content across state lines with automatic remapping to local standards
| | **Align content to curriculum** | Create or use educational materials that are aligned to official curricula.

[Contact us](mailto:support@learningcommons.org) ↗ to get access to this gated functionality. |
  • Feed lesson narratives, instructional routines, and Learning Components into LLM prompts to generate parent-facing activities
  • Map student performance data to standards
  • Use IM misconceptions to generate differentiated lesson plans and support RTI workflows
| | **Deliver personalized assessments** | Build adaptive experiences that go beyond content delivery into diagnostic assessment. |
  • Combine curricular data with student data to help teachers plan targeted weekly interventions
  • Combine Standards and Learning Components with student data to prepare teachers for observation and coaching
| ## Related topics Get started with the REST API, MCP server, or downloadable JSONL files. Query frameworks and standards in a step-by-step tutorial. Use progressions to find prerequisites and generate practice content. Walk through a crosswalk comparison tutorial with Jaccard analysis. # Agent plugins Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/agent-plugins Connect the ChatGPT plugin or Claude connector to query Knowledge Graph standards, learning components, and prerequisites in your AI conversations. Use agent plugins like our ChatGPT plugin or Claude connector to reference Knowledge Graph's comprehensive K-12 education data directly in your conversations. Instead of manually looking up standards codes or scanning lengthy documents, you can ask your agent what a standard entails, how it's broken down into learning components, and what prerequisites it requires. Both agent plugins rely on the [Knowledge Graph MCP Server](/knowledge-graph/using-knowledge-graph/mcp-server) to retrieve the relevant data. ## Tools | Tool | Description | | :------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **ChatGPT plugin** | Search for Learning Commons in the ChatGPT plugin library and add the Learning Commons plugin to your account.This plugin is included in OpenAI's K-12 Educator plugin experience for [ChatGPT for Teachers](https://chatgpt.com/plans/k12-teachers/) ↗ (US K-12) and ChatGPT Education. Individual ChatGPT users may also be able to add the plugin depending on their plan and settings. | | **Claude connector** | [Connect Learning Commons to Claude](https://claude.ai/directory/6e94f5fc-5dc8-4f0a-9fcf-741bcab4e034) ↗.This connector is free and available to all Claude users. It is also included in [Claude for Teachers](https://claude.com/solutions/teachers) ↗ (US K-12). | ## Capabilities Both integrations use these Knowledge Graph tools to make curriculum planning, lesson development, and standards alignment more efficient: | Capability | Description | | :----------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------ | | `find_standard_statement` | Look up standards codes relevant to your state | | `find_learning_components_from_standard` | Break broad standards down into specific teachable skills to target where students are struggling and to create focused practice activities | | `find_standards_progression_from_standard` | Identify the sequence of standards for a student's learning journey | ## Steps Search for **Learning Commons** in the ChatGPT plugin library and add it to your account. The plugin is included in OpenAI's K-12 Educator plugin experience for [ChatGPT for Teachers](https://chatgpt.com/plans/k12-teachers/) ↗ (US K-12) and ChatGPT Education. Individual ChatGPT users may also be able to add it depending on their plan and available plugin settings. Learning Commons ChatGPT plugin Ask ChatGPT to focus on a particular standard code (e.g., `5.NBT.A.2` or `RL.4.1`). Lesson ideas:
  • "I'm a teacher in Utah. Generate 3 project ideas that address standard 3.W\.1."
  • "Create a hands-on activity for my 5th graders that covers 5.NF.B.6 in Maine."
Assessment questions:
  • "Today in class, we will be covering the Texas standard 111.40.c.3.F. Create an exit ticket for my students."
  • "Make a quick formative assessment for California standard 3.MD.C.7."
Ways to support struggling students:
  • "I am a 4th-grade teacher in California. A student in my new class is struggling with the concepts related to 4.OA.A.3. Which prior standards should I focus on with them?"
  • "What foundational skills should a student master before we tackle North Carolina Standard NC.6.RP.1?"
Extra practice questions:
  • "I am an 8th-grade teacher in Maryland. Create extra practice problems to address the Learning Components of 8.F.B.4."
 Set up the [Knowledge Graph integration in Claude](https://claude.ai/directory/6e94f5fc-5dc8-4f0a-9fcf-741bcab4e034) ↗ from the Claude connector directory. Learning Commons Claude connector Ask Claude to focus on a particular standard code (e.g., `5.NBT.A.2` or `RL.4.1`). Lesson ideas:
  • "I'm a teacher in Iowa. Generate 3 project ideas that address W\.3.4."
  • "Create a hands-on activity for my 5th graders that covers 5.NF.B.6 in Maine."
Assessment questions:
  • "Today in class, we will be covering the Texas standard 111.40.c.3.F. Create an exit ticket for my students."
  • "Make a quick formative assessment for California standard 3.MD.C.7."
Ways to support struggling students:
  • "I am a 4th-grade teacher in California. A student in my new class is struggling with the concepts related to 4.OA.A.3. Which prior standards should I focus on with them?"
  • "What foundational skills should a student master before we tackle Illinois Standard 6.RP.A.1?"
Extra practice questions:
  • "I am an 8th-grade teacher in Maryland. Create extra practice problems to address the Learning Components of 8.F.B.4."
 ## Related topics Get set up with ChatGPT or Claude in a few minutes. Connect agents and IDEs to Knowledge Graph data via the Model Context Protocol. # Entities and relationships Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/graph-ql-api/entities-and-relationships Reference for the Knowledge Graph GraphQL schema (entity and relationship types) and examples of programmatic schema exploration using introspection.
Gated
All downloads in this dataset require approval to access. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for more details.
The Knowledge Graph [API](/api-reference/) supports GraphQL introspection, so you can programmatically discover types, fields, and relationships at runtime. ## Explore the schema Get all available types, explore a specific type (like `Lesson`), and more: ```text GraphQL theme={null} query { __schema { types { name kind description } } } query { __type(name: "Lesson") { name fields { name type { name kind } description } } } query { __schema { queryType { fields { name args { name type { name } } } } } } query { __type(name: "Lesson") { fields { name type { name ofType { name } } } } } ``` ```shell cURL theme={null} # Get all available types curl -X POST \ -H 'Content-Type: application/json' \ -H 'x-api-key: YOUR_API_KEY' \ -d '{"query":"{ __schema { types { name kind } } }"}' \ https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql # Explore a specific type (e.g., Lesson) curl -X POST \ -H 'Content-Type: application/json' \ -H 'x-api-key: YOUR_API_KEY' \ -d '{"query":"{ __type(name: \"Lesson\") { fields { name type { name } } } }"}' \ https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql ``` ```python Python theme={null} from gql import Client, gql # Get all available types schema_query = gql(""" query { __schema { types { name kind fields { name type { name } } } } } """) result = client.execute(schema_query) for type_info in result["__schema"]["types"]: if not type_info["name"].startswith("__"): # Skip introspection types print(f"Type: {type_info['name']} ({type_info['kind']})") ``` ## Entities The GraphQL API includes the following [entities](/knowledge-graph/understanding-knowledge-graph/core-concepts#entities): | Dataset | Entities | | :------------------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Standards](/knowledge-graph/schema-reference/standards#entities) | [`StandardsFramework`](/knowledge-graph/schema-reference/standards#standardsframework), [`StandardsFrameworkItem`](/knowledge-graph/schema-reference/standards#standardsframeworkitem) | | [Learning components](/knowledge-graph/schema-reference/learning-components#entities) | [`LearningComponent`](/knowledge-graph/schema-reference/learning-components#learningcomponent) | | [Curriculum](/knowledge-graph/schema-reference/curriculum#entities) | [`Activity`](/knowledge-graph/schema-reference/curriculum#activity), [`Assessment`](/knowledge-graph/schema-reference/curriculum#assessment), [`ClassroomMaterial`](/knowledge-graph/schema-reference/curriculum#classroommaterial), [`Course`](/knowledge-graph/schema-reference/curriculum#course), [`GlossaryTerm`](/knowledge-graph/schema-reference/curriculum#glossaryterm), [`InstructionalRoutine`](/knowledge-graph/schema-reference/curriculum#instructionalroutine), [`Lesson`](/knowledge-graph/schema-reference/curriculum#lesson), [`LessonGrouping`](/knowledge-graph/schema-reference/curriculum#lessongrouping), [`Material`](/knowledge-graph/schema-reference/curriculum#material) | | [Instructional guidance](/knowledge-graph/schema-reference/instructional-guidance#entities) | [`Factor`](/knowledge-graph/schema-reference/instructional-guidance#factor), [`LearnerModel`](/knowledge-graph/schema-reference/instructional-guidance#learnermodel), [`Strategy`](/knowledge-graph/schema-reference/instructional-guidance#strategy) | ## Relationships The GraphQL API includes the following [relationships](/knowledge-graph/understanding-knowledge-graph/core-concepts#relationships): | Dataset | Relationships | | :----------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Standards](/knowledge-graph/schema-reference/standards#relationships) | [`HasChildProperties`](/knowledge-graph/schema-reference/standards#haschild), [`SupportsProperties`](/knowledge-graph/schema-reference/standards#supports), [`HasEducationalAlignmentProperties`](/knowledge-graph/schema-reference/standards#haseducationalalignment), [`HasStandardAlignmentProperties`](/knowledge-graph/schema-reference/standards#hasstandardalignment) | | [Learning components](/knowledge-graph/schema-reference/learning-components#relationships) | [`SupportsProperties`](/knowledge-graph/schema-reference/learning-components#supports) | | [Learning progressions](/knowledge-graph/schema-reference/learning-progressions#relationships) | [`BuildsTowardsProperties`](/knowledge-graph/schema-reference/learning-progressions#buildstowards), [`RelatesToProperties`](/knowledge-graph/schema-reference/learning-progressions#relatesto) | | [Curriculum](/knowledge-graph/schema-reference/curriculum#relationships) | [`HasPartProperties`](/knowledge-graph/schema-reference/curriculum#haspart), [`HasEducationalAlignmentProperties`](/knowledge-graph/schema-reference/curriculum#haseducationalalignment), [`UsesRoutineProperties`](/knowledge-graph/schema-reference/curriculum#usesroutine), [`UsesProperties`](/knowledge-graph/schema-reference/curriculum#uses), [`HasDependencyProperties`](/knowledge-graph/schema-reference/curriculum#hasdependency), [`ReferencesProperties`](/knowledge-graph/schema-reference/curriculum#references), [`MutuallyExclusiveWithProperties`](/knowledge-graph/schema-reference/curriculum#mutuallyexclusivewith), [`HasReferenceProperties`](/knowledge-graph/schema-reference/curriculum#hasreference) | | [Instructional guidance](/knowledge-graph/schema-reference/instructional-guidance#relationships) | [`HasFactorProperties`](/knowledge-graph/schema-reference/instructional-guidance#hasfactor), [`HasStrategyProperties`](/knowledge-graph/schema-reference/instructional-guidance#hasstrategy), [`InteractsWithFactorProperties`](/knowledge-graph/schema-reference/instructional-guidance#interactswithfactor), [`TargetsFactorProperties`](/knowledge-graph/schema-reference/instructional-guidance#targetsfactor), [`RelevantToStandardProperties`](/knowledge-graph/schema-reference/instructional-guidance#relevanttostandard) | ## Related topics Learn how to make your first GraphQL request. Learn common GraphQL patterns for nodes, relationships, and filtering. # Getting started Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/graph-ql-api/getting-started Get started with the Knowledge Graph GraphQL API. Find the base URL, authenticate with an API key, and run your first query in cURL, Python, or JavaScript.
Gated
All downloads in this dataset require approval to access. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for more details.
## What you'll need * Base URL: ```text theme={null} POST https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql ``` * API key to include in the request headers: `x-api-key: YOUR_API_KEY` The Learning Commons team will securely share an API key for the GraphQL endpoint with you separately. * For Python: [`gql`](https://github.com/graphql-python/gql) for better GraphQL support, schema validation, and error handling ```bash theme={null} pip install gql[requests] ``` ## Query the data Use [GraphQL](https://graphql.org/learn/) queries to fetch the Knowledge Graph data you're interested in. For example, you can retrieve up to 5 courses with identifiers, names, and academic subjects using the queries below: ```bash cURL theme={null} curl -X POST \ -H 'Content-Type: application/json' \ -H 'x-api-key: YOUR_API_KEY' \ -d '{"query":"{ courses(limit: 5) { identifier name academicSubject } }"}' \ https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql ``` ```python Python theme={null} import os from gql import Client, gql from gql.transport.requests import RequestsHTTPTransport # Setup client transport = RequestsHTTPTransport( url="https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql", headers={"x-api-key": os.getenv("API_KEY")}, # Your API key use_json=True, ) client = Client(transport=transport, fetch_schema_from_transport=False) # Execute query query = gql(""" { courses(limit: 5) { identifier name academicSubject } } """) result = client.execute(query) print(result) ``` ```javascript JavaScript theme={null} const url = "https://cumtxmqb68.execute-api.us-west-2.amazonaws.com/staging/v1.0.0/graphql"; const apiKey = process.env.API_KEY; // Your API key const query = ` { courses(limit: 5) { identifier name academicSubject } } `; fetch(url, { method: "POST", headers: { "Content-Type": "application/json", "x-api-key": apiKey, }, body: JSON.stringify({ query }), }) .then((response) => response.json()) .then((data) => console.log(data)) .catch((error) => console.error("Error:", error)); ``` ## Troubleshooting ### Query too complex If your query times out or fails: * Reduce the depth of nested relationships * Implement pagination on nested connections * Split complex queries into multiple simpler ones ### No results returned If your query returns an empty response: * Check filter conditions are correct * Verify field names match the schema * Use introspection queries to explore available fields ### Authentication errors If your query fails authentication: * Ensure your API key is valid and active * Check that the `x-api-key` header is properly set ### Rate limiting The API implements rate limiting to ensure fair usage: * 2 requests per second with burst capacity up to 10 requests * Exponential backoff when receiving rate limit errors (`HTTP 429: Too Many Requests`) Reach out to [support@learningcommons.org](mailto:support@learningcommons.org) ↗ to request rate limit adjustments. ### Server errors Large queries may cause `HTTP 502/504` errors: * Reduce page size to fewer than 1000 items * Retry the query ### Payload and timeout limits The API has the following technical limitations: * **Request timeout:** 30 sec * **Request payload size:** 10 MB * **Response payload size:** 6 MB * **Query complexity:** Deeply nested queries may hit processing limits To avoid limits: * Use pagination for large result sets * Limit field selection to only required data * Avoid deeply nested queries (>5 levels) * Break up complex queries or add filtering (e.g., grade level or subject) ### GraphQL errors GraphQL errors are returned in the response body: ```text theme={null} { "errors": [ { "message": "Field 'invalidField' doesn't exist on type 'Lesson'", "locations": [{"line": 2, "column": 5}] } ] } ``` ## Related topics Learn common GraphQL patterns for nodes, relationships, and filtering. Explore the GraphQL Entities and relationships types available through introspection. # Query patterns Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/graph-ql-api/query-patterns Learn common GraphQL query patterns for Knowledge Graph, including entity and relationship queries, grade and subject filters, and curriculum examples.
Gated
All downloads in this dataset require approval to access. Contact [support@learningcommons.org](mailto:support@learningcommons.org) ↗ for more details.
## Entity queries ### List lessons by grade level ```text theme={null} query { lessons(where: { gradeLevel_INCLUDES: "K" }, limit: 10) { identifier name gradeLevel courseCode timeRequired } } ``` ## Relationship queries ### List activities and their materials ```text theme={null} query { activities(limit: 5) { identifier name hasPartMaterials { identifier name materialType content } } } ``` ### List educational alignments ```text theme={null} query { lessons(limit: 3) { identifier name hasEducationalAlignmentStandardsFrameworkItems { identifier description gradeLevel } } } ``` ## Advanced filtering ### By grade levels ```text theme={null} query { lessons(where: { gradeLevel_INCLUDES: "K" }, limit: 10) { identifier name gradeLevel } } ``` ### By subject and author ```text theme={null} query { courses(where: { academicSubject: "Mathematics", author_CONTAINS: "Illustrative Mathematics" }, limit: 5) { identifier name author academicSubject } } ``` ## IM® v.360 course queries ### List courses Return all IM courses in the Knowledge Graph. ```graphql GraphQL theme={null} { courses(where: { author: "Illustrative Mathematics" }) { name identifier gradeLevel } } ``` ```cypher Cypher theme={null} MATCH (c:Course {author:'Illustrative Mathematics'}) RETURN c.name, c.identifier, c.gradeLevel ``` ### List units in a course Get all units for Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { curriculumLabel: "Unit" }) { ordinalName name identifier } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[:hasPart]->(u:LessonGrouping {curriculumLabel: "Unit"}) RETURN u.ordinalName, u.name, u.identifier ``` ### List sections in a course Return all sections for each Unit in grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { curriculumLabel: "Unit" }) { ordinalName hasPartLessonGroupings(where: { curriculumLabel: "Section" }) { ordinalName name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[:hasPart]->(u:LessonGrouping {curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {curriculumLabel: "Section"}) RETURN u.ordinalName AS unit, s.ordinalName AS section, s.name AS sectionName, s.identifier AS sectionId ``` ### List lessons in a course Return all lessons for each section of each unit in Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { curriculumLabel: "Unit" }) { ordinalName hasPartLessonGroupings(where: { curriculumLabel: "Section" }) { ordinalName hasPartLessons { ordinalName name identifier } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[:hasPart]->(u:LessonGrouping {curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {curriculumLabel: "Section"}) -[:hasPart]->(l:Lesson) RETURN u.ordinalName AS unit, s.ordinalName AS section, l.ordinalName AS lesson, l.name AS lessonName, l.identifier AS lessonId ``` ### List instructional routines in a course Return all instructional routines used in Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { usesRoutineInstructionalRoutines { name identifier } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[:usesRoutine]->(ir:InstructionalRoutine) RETURN DISTINCT ir.name, ir.identifier ``` ### List CCSSM standards aligned to a course Return all CCSSM standards that have educational alignment with Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasEducationalAlignmentStandardsFrameworkItemsConnection( where: { node: { statementType: "Standard" } } ) { edges { properties { curriculumAlignmentType } node { statementCode description identifier } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[a:hasEducationalAlignment]->(cfi:StandardsFrameworkItem) WHERE cfi.statementType = "Standard" RETURN DISTINCT cfi.statementCode, cfi.description, cfi.identifier, a.curriculumAlignmentType ``` ### Get course guide for a course Return course guide information for grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartMaterials(where: { name: "Course Guide" }) { identifier content } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author:'Illustrative Mathematics'})-[:hasPart]->(m:Material) WHERE m.name = 'Course Guide' RETURN m.identifier, m.content ``` ### Get course by its course ID Return metadata and content for the course ID \[xxxxx]. ```graphql GraphQL theme={null} { courses( where: { author: "Illustrative Mathematics" identifier: "im:01dac62a-f836-5da5-bae4-1df14f1dfa8f" } ) { name courseCode hasPartMaterials { content } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {author:'Illustrative Mathematics', identifier: "im:01dac62a-f836-5da5-bae4-1df14f1dfa8f"})-[:hasPart]-(m:Material) RETURN c.name, c.courseCode, m.content ``` ## IM® v.360 unit queries ### List sections in a unit Return all sections for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings( where: { ordinalName: "Unit 1", curriculumLabel: "Unit" } ) { hasPartLessonGroupings(where: { curriculumLabel: "Section" }) { ordinalName name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1", curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {curriculumLabel: "Section"}) RETURN s.ordinalName, s.name, s.identifier ``` ### List lessons in a unit Return all lessons for each Section for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings( where: { ordinalName: "Unit 1", curriculumLabel: "Unit" } ) { hasPartLessonGroupings(where: { curriculumLabel: "Section" }) { ordinalName hasPartLessons { ordinalName name identifier } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1", curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {curriculumLabel: "Section"}) -[:hasPart]->(l:Lesson) RETURN s.ordinalName AS section, l.ordinalName AS lesson, l.name AS lessonName, l.identifier as lessonId ``` ### List CCSSM standards aligned to a unit Return all the CCSSM standards that have educational alignment with Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings( where: { ordinalName: "Unit 1", curriculumLabel: "Unit" } ) { hasEducationalAlignmentCfItemsConnection( where: { node: { CASE_CFItemType: "Standard" } } ) { edges { properties { curriculumAlignmentType } node { CASE_humanCodingScheme CASE_fullStatement identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1", curriculumLabel: "Unit"}) -[a:hasEducationalAlignment]->(cfi:CFItem) WHERE cfi.`CASE:CFItemType` = "Standard" RETURN DISTINCT cfi.`CASE:humanCodingScheme`, cfi.`CASE:fullStatement`, cfi.identifier, a.`relationship_properties.curriculumAlignmentType` ``` ### List prerequisite units for a unit Return the prerequisite units for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { lessonGroupings(where: { ordinalName: "Unit 1", courseCode: "im360:6" }) { lessonGroupingshasDependency { ordinalName name identifier } } } ``` ```cypher Cypher theme={null} MATCH (u:LessonGrouping {ordinalName: "Unit 1", courseCode: "im360:6"}) <-[:hasDependency]-(prereq:LessonGrouping) RETURN prereq.ordinalName, prereq.name, prereq.identifier ``` ### List dependent units for a unit Return units depending on Unit 1 of Grade 6. ```graphql GraphQL theme={null} { lessonGroupings(where: { ordinalName: "Unit 1", courseCode: "im360:6" }) { hasDependencyLessonGroupings { ordinalName name identifier } } } ``` ```cypher Cypher theme={null} MATCH (u:LessonGrouping {ordinalName: "Unit 1", courseCode: "im360:6"}) -[:hasDependency]->(dep:LessonGrouping) RETURN dep.ordinalName, dep.name, dep.identifier ``` ### Get family materials for a unit Return the family material information for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartMaterials(where: { name_CONTAINS: "Family Materials" }) { name identifier content } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(m:Material) WHERE m.name CONTAINS 'Family Materials' RETURN m.name, m.identifier, m.content ``` ### Get unit overview for a unit Return the unit overview information for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartMaterials(where: { name_CONTAINS: "Overview" }) { name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(m:Material) WHERE m.name CONTAINS 'Overview' RETURN m.name, m.identifier ``` ### List end-of-unit assessments for a unit Return the end-of-unit assessments for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartAssessments(where: { curriculumLabel_CONTAINS: "End-of-Unit" }) { name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel CONTAINS "End-of-Unit" RETURN a.name, a.identifier ``` ### List *Check Your Readiness* assessments for a unit Return the *Check Your Readiness* assessments for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartAssessments( where: { curriculumLabel_CONTAINS: "Check Your Readiness" } ) { name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel CONTAINS "Check Your Readiness" RETURN a.name, a.identifier ``` ### List mid-unit assessments for a unit Return the mid-unit assessments for Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartAssessments(where: { curriculumLabel_CONTAINS: "Mid-Unit" }) { name identifier } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel CONTAINS "Mid-Unit" RETURN a.name, a.identifier ``` ### List glossary terms referenced by a unit Return the glossary terms referenced by Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings { hasPartLessons { referencesGlossaryTerms { name description identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart*]->(l:Lesson)-[:references]->(g:GlossaryTerm) RETURN DISTINCT g.name, g.description, g.identifier ``` ### Get unit by its unit ID Return metadata and content for the unit ID \[xxxxx]. ```graphql GraphQL theme={null} { lessonGroupings( where: { identifier: "im:a0e15ae9-dd70-5df0-93ad-9d6b99fc5ad2" } ) { name ordinalName hasPartMaterials { content } } } ``` ```cypher Cypher theme={null} MATCH (u:LessonGrouping {identifier: "im:a0e15ae9-dd70-5df0-93ad-9d6b99fc5ad2"}) -[:hasPart]-(m:Material) RETURN u.name, u.ordinalName, m.content ``` ## IM® v.360 section queries ### List lessons in a section Return all lessons for Section A of Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings( where: { ordinalName: "Unit 1", curriculumLabel: "Unit" } ) { hasPartLessonGroupings( where: { ordinalName: "Section A", curriculumLabel: "Section" } ) { hasPartLessons { ordinalName name identifier } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1", curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {ordinalName: "Section A", curriculumLabel: "Section"}) -[:hasPart]->(l:Lesson) RETURN l.ordinalName, l.name, l.identifier ``` ### List CCSSM standards aligned to a section Get all the CCSSM standards that have educational alignment with Section A of Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings( where: { ordinalName: "Unit 1", curriculumLabel: "Unit" } ) { hasPartLessonGroupings( where: { ordinalName: "Section A", curriculumLabel: "Section" } ) { hasEducationalAlignmentStandardsFrameworkItemsConnection( where: { node: { statementType: "Standard" } } ) { edges { properties { curriculumAlignmentType } node { statementCode description identifier } } } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1", curriculumLabel: "Unit"}) -[:hasPart]->(s:LessonGrouping {ordinalName: "Section A", curriculumLabel: "Section"}) -[a:hasEducationalAlignment]->(cfi:StandardsFrameworkItem) WHERE cfi.statementType = "Standard" RETURN DISTINCT cfi.statementCode, cfi.description, cfi.identifier, a.curriculumAlignmentType ``` ### Get section narrative for a section Return the section narrative information for section A of unit 1 of grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartMaterials { name identifier content } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName: "Section A"}) -[:hasPart]->(m:Material) RETURN m.name, m.identifier, m.content ``` ### Get section checkpoint assessment for a section Return the section checkpoint assessment for Section A of Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6", author: "Illustrative Mathematics" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartAssessments(where: { curriculumLabel_CONTAINS: "Checkpoint" }) { name identifier } } } } } ``` ```cypher Cypher theme={null} MATCH (:Course {name: "Grade 6", author: "Illustrative Mathematics"}) -[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName: "Section A"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel CONTAINS "Checkpoint" RETURN a.name, a.identifier ``` ### Get section by its section ID Return metadata and content for the section ID \[xxxxx]. ```graphql GraphQL theme={null} { lessonGroupings( where: { identifier: "im:0908dab1-c834-5194-947b-492a1348a403" } ) { identifier name ordinalName hasPartMaterials { content } } } ``` ```cypher Cypher theme={null} MATCH (s:LessonGrouping {identifier: "im:0908dab1-c834-5194-947b-492a1348a403"})-[:hasPart]-(m:Material) RETURN s.identifier, s.name, s.ordinalName, m.content ``` ## IM® v.360 lesson queries ### List activities in a lesson Return all activities that are part of lesson 1, section A, unit 1 of grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { hasPartActivities { name identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 6"})-[:hasPart]->(u:LessonGrouping {ordinalName:"Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName:"Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:hasPart]->(a:Activity) RETURN a.name, a.identifier ``` ### List cool-down assessments in a lesson Get cool-down assessments of Lesson 1, Section A, Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { hasPartAssessments(where: { curriculumLabel: "Cool-down" }) { name identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 6"})-[:hasPart]->(u:LessonGrouping {ordinalName:"Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName:"Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel = "Cool-down" RETURN a.name, a.identifier ``` ### List practice problems in a lesson Get practice problems of Lesson 1, Section A, Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { hasPartAssessments(where: { curriculumLabel: "Practice Problems" }) { name identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 6"})-[:hasPart]->(u:LessonGrouping {ordinalName:"Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName:"Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:hasPart]->(a:Assessment) WHERE a.curriculumLabel = "Practice Problems" RETURN a.name, a.identifier ``` ### List classroom materials in a lesson Get all classroom materials used in Lesson 1, Section A, Unit 1 of Grade 3. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 3" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { usesClassroomMaterials { name identifier description } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 3"})-[:hasPart]->(u:LessonGrouping {ordinalName:"Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName:"Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:uses]->(m:ClassroomMaterial) RETURN m.name, m.identifier ``` ### List glossary terms referenced by a lesson Return all glossary terms referenced in Lesson 1, Section A, Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { referencesGlossaryTerms { name description identifier } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 6"})-[:hasPart]->(u:LessonGrouping {ordinalName:"Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName:"Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:references]->(g:GlossaryTerm) RETURN g.name, g.identifier ``` ### List standards aligned to a lesson Return all common core standards educationally aligned with Lesson 1, Section A, Unit 1 of Grade 6. ```graphql GraphQL theme={null} { courses(where: { name: "Grade 6" }) { hasPartLessonGroupings(where: { ordinalName: "Unit 1" }) { hasPartLessonGroupings(where: { ordinalName: "Section A" }) { hasPartLessons(where: { ordinalName: "Lesson 1" }) { hasEducationalAlignmentStandardsFrameworkItems { identifier description statementCode statementType } } } } } } ``` ```cypher Cypher theme={null} MATCH (c:Course {name: "Grade 6"})-[:hasPart]->(u:LessonGrouping {ordinalName: "Unit 1"}) -[:hasPart]->(s:LessonGrouping {ordinalName: "Section A"})-[:hasPart]->(l:Lesson {ordinalName: "Lesson 1"}) -[:hasEducationalAlignment]->(cf:StandardsFrameworkItem) RETURN cf.identifier, cf.description, cf.statementCode ``` ### Get lesson by its lesson ID Return metadata and content for the lesson ID \[xxxxx]. ```graphql GraphQL theme={null} { lessons( where: { author: "Illustrative Mathematics" identifier: "im:3ac685eb-79b3-5c19-952e-c1a71a5017e9" } ) { name courseCode hasPartMaterials { content } } } ``` ```cypher Cypher theme={null} MATCH (c:Lesson {author:'Illustrative Mathematics', identifier: "im:3ac685eb-79b3-5c19-952e-c1a71a5017e9"})-[:hasPart]-(m:Material) RETURN c.name, c.courseCode, m.content ``` ## IM® v.360 activity queries **List instructional routines in an activity**\ "Which routines are used in activity ID \[xxxxx]?" ```graphql GraphQL theme={null} { activities(where: { identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae" }) { usesRoutineInstructionalRoutines { name identifier description } } } ``` ```cypher Cypher theme={null} MATCH (a:Activity {identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae"})-[:usesRoutine]->(r:InstructionalRoutine) RETURN r.name, r.identifier, r.description ``` **List common core math standards aligned to an activity**\ "Return all common core standards educationally aligned with Activity ID \[xxxxx]." ```graphql GraphQL theme={null} { activities(where: { identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae" }) { hasEducationalAlignmentStandardsFrameworkItems { identifier description statementCode statementType } } } ``` ```cypher Cypher theme={null} MATCH (a:Activity {identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae"}) -[:hasEducationalAlignment]->(cf:StandardsFrameworkItem) RETURN cf.identifier, cf.description, cf.statementCode ``` ### Get activity by its activity ID Return metadata and content for the activity ID \[xxxxx]. ```graphql GraphQL theme={null} { activities(where: { identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae" }) { name ordinalName hasPartMaterials { identifier content } } } ``` ```cypher Cypher theme={null} MATCH (s:Activity {identifier: "im:44adb838-f550-5efc-a875-6a991b52b7ae"})-[:hasPart]-(m:Material) RETURN m.identifier, s.name, s.ordinalName, m.content ``` ## Academic standard queries ### List standards documents Return all standard documents available in the Knowledge Graph. ```graphql GraphQL theme={null} { standardsFrameworks { identifier name } } ``` ```cypher Cypher theme={null} MATCH (doc:StandardsFramework) RETURN doc.identifier, doc.name ``` ### List standards documents for a subject and state Return all Math standards documents from California. ```graphql GraphQL theme={null} { standardsFrameworks( where: { academicSubject: "Mathematics", jurisdiction: "California" } ) { identifier name } } ``` ```cypher Cypher theme={null} MATCH (doc:StandardsFramework) WHERE doc.academicSubject = "Mathematics" AND doc.jurisdiction = "California" RETURN doc.identifier, doc.name ``` ### Get standards document by its document ID Return standards document with identifier \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworks( where: { identifier: "2d08331b-3769-5b2b-981c-52b03c5e73d1" } ) { identifier name } } ``` ```cypher Cypher theme={null} MATCH (doc:StandardsFramework {identifier: "2d08331b-3769-5b2b-981c-52b03c5e73d1"}) RETURN doc.identifier, doc.name ``` ### List standards in a document Return all standards that are part of a standard document ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworks( where: { identifier: "2d08331b-3769-5b2b-981c-52b03c5e73d1" } ) { hasChildStandardsFrameworkItems { identifier description statementType statementCode } } } ``` ```cypher Cypher theme={null} MATCH (:StandardsFramework {identifier: "2d08331b-3769-5b2b-981c-52b03c5e73d1"})-[:hasChild]->(ci:StandardsFrameworkItem) RETURN ci.identifier, ci.description, ci.statementCode ``` ### List child standards for a standard Return all standards that are children of standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872" } ) { hasChildStandardsFrameworkItems { identifier description statementCode } } } ``` ```cypher Cypher theme={null} MATCH (:StandardsFrameworkItem {identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872"})-[:hasChild]->(ci:StandardsFrameworkItem) RETURN ci.identifier, ci.description, ci.statementCode ``` ### Get parent standard for a standard Return the immediate parent standard of standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { hasChildStandardsFrameworkItems_SOME: { identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872" } } ) { identifier description statementCode } } ``` ```cypher Cypher theme={null} MATCH (ci:StandardsFrameworkItem)-[:hasChild]->(:StandardsFrameworkItem {identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872"}) RETURN ci.identifier, ci.description, ci.statementCode ``` ### Get standard by its standard code Return content and metadata for standard code '7.G.A.1'. ```graphql GraphQL theme={null} { standardsFrameworkItems(where: { statementCode: "7.G.A.1" }) { identifier description statementType } } ``` ```cypher Cypher theme={null} MATCH (ci: StandardsFrameworkItem{statementCode: "7.G.A.1"}) RETURN ci.identifier, ci.description ``` ### Get standard by its standard ID Return content and metadata for standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872" } ) { identifier description statementType statementCode } } ``` ```cypher Cypher theme={null} MATCH (ci:StandardsFrameworkItem {identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872"}) RETURN ci.identifier, ci.description, ci.statementCode ``` ### List standards for a grade Return all math standards from grade level 6. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { gradeLevel_INCLUDES: "6", academicSubject: "Mathematics" } ) { identifier statementCode description } } ``` ```cypher Cypher theme={null} MATCH (cfi:StandardsFrameworkItem) WHERE "6" in cfi.gradeLevel AND cfi.academicSubject = 'Mathematics' RETURN cfi.identifier, cfi.statementCode, cfi.description ``` ## Learning progression queries ### List standards that build toward a standard Return all standards that build toward standard 6.NS.B.3. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { buildsTowardsStandardsFrameworkItems_SOME: { statementCode: "6.NS.B.3" } } ) { identifier statementCode description } } ``` ```cypher Cypher theme={null} MATCH (s:StandardsFrameworkItem)-[:buildsTowards]->(d:StandardsFrameworkItem) WHERE d.statementCode = "6.NS.B.3" RETURN s.identifier, s.statementCode, s.description ``` ### List standards related to a standard Return all standards that relate to standard 5.NBT.B.7. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { relatesToStandardsFrameworkItems_SOME: { statementCode: "5.NBT.B.7" } } ) { identifier statementCode description } } ``` ```cypher Cypher theme={null} MATCH (s:StandardsFrameworkItem)-[:relatesTo]->(d:StandardsFrameworkItem) WHERE d.statementCode = "5.NBT.B.7" RETURN s.identifier, s.statementCode, s.description ``` ## Learning component queries ### List learning components Return a list of all learning components in Knowledge Graph. ```graphql GraphQL theme={null} { learningComponents { identifier description academicSubject } } ``` ```cypher Cypher theme={null} MATCH (n:LearningComponent) RETURN n.identifier, n.description, n.academicSubject ``` ### Get learning component by its ID Return a learning component that matches the ID \[xxxxx]. ```graphql GraphQL theme={null} { learningComponents( where: { identifier: "4219c4aa-da1f-5f0f-bca8-0482f1d5a02b" } ) { identifier description academicSubject } } ``` ```cypher Cypher theme={null} MATCH (n:LearningComponent{identifier: "4219c4aa-da1f-5f0f-bca8-0482f1d5a02b"}) RETURN n.identifier, n.description, n.academicSubject ``` ## Standards + curriculum queries ### List courses aligned to a standard Return the courses aligned with standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775" } ) { courseshasEducationalAlignment { name identifier } } } ``` ```cypher Cypher theme={null} MATCH (c:Course)-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775"}) RETURN c.name, c.identifier ``` ### List units aligned to a standard Return the units aligned with standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775" } ) { lessonGroupingshasEducationalAlignment(where: { curriculumLabel: "Unit" }) { name ordinalName identifier } } } ``` ```cypher Cypher theme={null} MATCH (u:LessonGrouping {curriculumLabel: "Unit"})-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775"}) RETURN u.name, u.identifier ``` ### List sections aligned to a standard Return the sections aligned with standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775" } ) { lessonGroupingshasEducationalAlignment( where: { curriculumLabel: "Section" } ) { name ordinalName identifier } } } ``` ```cypher Cypher theme={null} MATCH (s:LessonGrouping {curriculumLabel: "Section"})-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775"}) RETURN s.name, s.identifier ``` ### List lessons aligned to a standard Return the lessons that are aligned with standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775" } ) { lessonshasEducationalAlignment { name ordinalName identifier } } } ``` ```cypher Cypher theme={null} MATCH (l:Lesson)-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775"}) RETURN l.name, l.identifier ``` ### List activities aligned to a standard Return the activities that are aligned with the standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775" } ) { activitieshasEducationalAlignment { name ordinalName identifier } } } ``` ```cypher Cypher theme={null} MATCH (a:Activity)-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "62508493-c9ae-5c4a-b317-94d80fe6d775"}) RETURN a.name, a.identifier ``` ### List assessments aligned to a standard Return the assessments aligned with standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "6998c1e0-d5d3-5f9b-9bb6-f167772a499f" } ) { assessmentshasEducationalAlignment { name identifier } } } ``` ```cypher Cypher theme={null} MATCH (assess:Assessment)-[:hasEducationalAlignment]->(:StandardsFrameworkItem {identifier: "6998c1e0-d5d3-5f9b-9bb6-f167772a499f"}) RETURN assess.name, assess.identifier ``` ## Learning component + standards queries ### List learning components for a grade Return all learning components that support all standards from Grade 6. ```graphql GraphQL theme={null} { standardsFrameworkItems(where: { gradeLevel_INCLUDES: "6" }) { learningComponentssupports { identifier description } } } ``` ```cypher Cypher theme={null} MATCH (cfi:StandardsFrameworkItem)-[:supports]-(l:LearningComponent) WHERE "6" in cfi.gradeLevel RETURN l.identifier, l.description ``` ### List learning components supporting a standard Return all learning components that support standard ID \[xxxxx]. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { identifier: "ef129d7a-3f29-58ed-80e3-ba5186af5872" } ) { learningComponentssupports { identifier description } } } ``` ```cypher Cypher theme={null} MATCH (cfi:StandardsFrameworkItem)-[:supports]-(l:LearningComponent) WHERE cfi.identifier = "ef129d7a-3f29-58ed-80e3-ba5186af5872" RETURN l.identifier, l.description ``` ### List standards supported by a learning component Return all standards that are supported by learning component ID \[xxxxx]. ```graphql GraphQL theme={null} { learningComponents( where: { identifier: "0013fbee-3e76-500f-9978-42aa1a65f105" } ) { supportsStandardsFrameworkItems { identifier description } } } ``` ```cypher Cypher theme={null} MATCH (cfi:StandardsFrameworkItem)-[:supports]-(l:LearningComponent) WHERE l.identifier = "0013fbee-3e76-500f-9978-42aa1a65f105" RETURN cfi.identifier, cfi.description ``` ## Learning component + standards + IM® v.360 queries ### List learning components supporting an IM® v.360 lesson Return all learning components that support lesson ID \[xxxxx]. ```graphql GraphQL theme={null} { lessons(where: { identifier: "im:ecf6aa89-0fc9-501c-a4ae-531d9faf8c39" }) { hasEducationalAlignmentStandardsFrameworkItems { learningComponentssupports { identifier description } } } } ``` ```cypher Cypher theme={null} MATCH (l:Lesson{identifier:"im:ecf6aa89-0fc9-501c-a4ae-531d9faf8c39"})-[:hasEducationalAlignment]->(c:StandardsFrameworkItem)-[:supports]-(lc:LearningComponent) RETURN lc.identifier, lc.description ``` ## Standard crosswalk queries ### List crosswalks Return all state to CCSSM standard alignments ordered by Jaccard similarity score. ```graphql GraphQL theme={null} { standardsFrameworkItems { statementCode jurisdiction hasStandardAlignmentStandardsFrameworkItemsConnection { edges { node { statementCode jurisdiction } properties { jaccard stateLCCount ccssLCCount sharedLCCount } } } } } ``` ```cypher Cypher theme={null} MATCH (state:StandardsFrameworkItem)-[r:hasStandardAlignment]->(ccss:StandardsFrameworkItem) RETURN state.statementCode AS state_standard_code, state.jurisdiction AS state_jurisdiction, ccss.statementCode AS ccss_standard_code, ccss.jurisdiction AS ccss_jurisdiction, r.jaccard, r.stateLCCount, r.ccssLCCount, r.sharedLCCount ORDER BY r.jaccard DESC ``` ### List crosswalks for a state Return all crosswalks for Texas standards to CCSSM with full metadata. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { jurisdiction: "Texas", academicSubject: "Mathematics" } ) { jurisdiction statementCode gradeLevel description academicSubject hasStandardAlignmentStandardsFrameworkItemsConnection { edges { node { statementCode gradeLevel description academicSubject } properties { jaccard sharedLCCount stateLCCount ccssLCCount } } } } } ``` ```cypher Cypher theme={null} MATCH (state:StandardsFrameworkItem)-[r:hasStandardAlignment]->(ccss:StandardsFrameworkItem) WHERE state.jurisdiction = 'Texas' AND state.academicSubject = 'Mathematics' RETURN state.jurisdiction AS state_jurisdiction, state.statementCode AS state_standard_code, state.gradeLevel AS state_grade_level, state.description AS state_description, state.academicSubject AS state_academic_subject, ccss.statementCode AS ccss_standard_code, ccss.gradeLevel AS ccss_grade_level, ccss.description AS ccss_description, ccss.academicSubject AS ccss_academic_subject, r.jaccard, r.sharedLCCount, r.stateLCCount, r.ccssLCCount ORDER BY state.statementCode, ccss.statementCode, r.jaccard DESC ``` ### Filter crosswalks by similarity threshold Return all Texas crosswalks with Jaccard score of 0.7 or higher. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { jurisdiction: "Texas" hasStandardAlignmentStandardsFrameworkItemsConnection_SOME: { edge: { jaccard_GTE: 0.7 } } } ) { jurisdiction statementCode hasStandardAlignmentStandardsFrameworkItemsConnection( where: { edge: { jaccard_GTE: 0.7 } } ) { edges { node { statementCode } properties { jaccard sharedLCCount stateLCCount ccssLCCount } } } } } ``` ```cypher Cypher theme={null} MATCH (state:StandardsFrameworkItem)-[r:hasStandardAlignment]->(ccss:StandardsFrameworkItem) WHERE r.jaccard >= 0.7 AND state.jurisdiction = 'Texas' RETURN state.jurisdiction AS state_jurisdiction, state.statementCode AS state_standard_code, ccss.statementCode AS ccss_standard_code, r.jaccard, r.sharedLCCount, r.stateLCCount, r.ccssLCCount ORDER BY ccss.statementCode, r.jaccard DESC ``` ### Get best state match for a CCSS standard Return the top Texas standards that best match CCSS standard '6.EE.B.5' with full metadata. ```graphql GraphQL theme={null} { standardsFrameworkItems( where: { statementCode: "6.EE.B.5", jurisdiction: "Multi-State" } ) { statementCode description gradeLevel jurisdiction academicSubject standardsFrameworkItemshasStandardAlignmentConnection( where: { node: { jurisdiction: "Texas" } } ) { edges { node { statementCode description gradeLevel jurisdiction academicSubject } properties { jaccard sharedLCCount stateLCCount ccssLCCount } } } } } ``` ```cypher Cypher theme={null} MATCH (state:StandardsFrameworkItem)-[r:hasStandardAlignment]->(ccss:StandardsFrameworkItem) WHERE ccss.statementCode = '6.EE.B.5' AND ccss.jurisdiction = 'Multi-State' AND state.jurisdiction = 'Texas' RETURN ccss.statementCode AS ccss_standard_code, ccss.description AS ccss_description, ccss.gradeLevel AS ccss_grade_level, ccss.jurisdiction AS ccss_jurisdiction, ccss.academicSubject AS ccss_academic_subject, state.statementCode AS state_standard_code, state.description AS state_description, state.gradeLevel AS state_grade_level, state.jurisdiction AS state_jurisdiction, state.academicSubject AS state_academic_subject, r.jaccard, r.sharedLCCount, r.stateLCCount, r.ccssLCCount ORDER BY r.jaccard DESC LIMIT 10 ``` ## Instructional guidance queries ### List learner models Return all learner models available in the Knowledge Graph. ```graphql GraphQL theme={null} { learnerModels { identifier name description academicSubject gradeLevel } } ``` ```cypher Cypher theme={null} MATCH (lm:LearnerModel) RETURN lm.identifier, lm.name, lm.description, lm.academicSubject, lm.gradeLevel ``` ### List factors for a learner model Return all factors associated with the 'Portrait of a Learner 4-8' learner model. ```graphql GraphQL theme={null} { learnerModels(where: { name: "Portrait of a Learner 4-8" }) { name identifier description hasFactorFactors { identifier name description category gradeLevel } } } ``` ```cypher Cypher theme={null} MATCH (lm:LearnerModel {name: 'Portrait of a Learner 4-8'})-[:hasFactor]->(f:Factor) RETURN lm.name AS learner_model_name, lm.identifier AS learner_model_id, f.identifier AS factor_id, f.name AS factor_name, f.description AS factor_description, f.category AS factor_category, f.gradeLevel AS factor_grade_level ``` ### List strategies for a learner model Return all strategies associated with the 'Portrait of a Learner 4-8' learner model. ```graphql GraphQL theme={null} { learnerModels(where: { name: "Portrait of a Learner 4-8" }) { name identifier description hasStrategyStrategies { identifier name description category gradeLevel } } } ``` ```cypher Cypher theme={null} MATCH (lm:LearnerModel {name: 'Portrait of a Learner 4-8'})-[:hasStrategy]->(s:Strategy) RETURN lm.name AS learner_model_name, lm.identifier AS learner_model_id, s.identifier AS strategy_id, s.name AS strategy_name, s.description AS strategy_description, s.category AS strategy_category, s.gradeLevel AS strategy_grade_level ``` ### List factors that interact with a factor Return all factors that interact with 'Working Memory' factor from Building Math 3-6. ```graphql GraphQL theme={null} { factors(where: { identifier: "9501e48b-c985-501f-84ad-98c3f271e322" }) { name identifier description category gradeLevel academicSubject interactsWithFactorFactors { identifier name description category gradeLevel } } } ``` ```cypher Cypher theme={null} MATCH (f:Factor {identifier: '9501e48b-c985-501f-84ad-98c3f271e322'})-[:interactsWithFactor]->(related:Factor) RETURN f.name AS factor_name, f.identifier AS factor_id, f.gradeLevel AS grade_level, f.academicSubject AS academic_subject, related.identifier AS related_factor_id, related.name AS related_factor_name, related.description AS related_factor_description, related.category AS related_factor_category, related.gradeLevel AS related_factor_grade_level ``` ### List strategies that target a factor Return all strategies that target 'Working Memory' factor from Building Math 3-6. ```graphql GraphQL theme={null} { factors(where: { identifier: "9501e48b-c985-501f-84ad-98c3f271e322" }) { name identifier category gradeLevel academicSubject strategiestargetsFactorConnection { edges { node { name category } properties { connectionType factorCategory } } } } } ``` ```cypher Cypher theme={null} MATCH (s:Strategy)-[r:targetsFactor]->(f:Factor {identifier: '9501e48b-c985-501f-84ad-98c3f271e322'}) RETURN f.name AS factor_name, f.gradeLevel AS grade_level, f.academicSubject AS academic_subject, s.name AS strategy, s.category AS strategy_category, r.connectionType AS connection, r.factorCategory AS factor_category ORDER BY s.name ``` ### List standards relevant to a factor Return all standards that are relevant to 'Algebraic Thinking' factor. ```graphql GraphQL theme={null} { factors(where: { name: "Algebraic Thinking" }) { name identifier category relevantToStandardStandardsFrameworkItems { statementCode description gradeLevel jurisdiction academicSubject } } } ``` ```cypher Cypher theme={null} MATCH (f:Factor {name: 'Algebraic Thinking'})-[:relevantToStandard]->(s:StandardsFrameworkItem) RETURN f.name AS factor_name, f.identifier AS factor_id, s.statementCode AS standard_code, s.description AS standard_description, s.gradeLevel AS grade_level, s.jurisdiction AS jurisdiction, s.academicSubject AS academic_subject ORDER BY s.statementCode ``` ## Related topics Learn how to make your first GraphQL request. Explore the GraphQL schema types available through introspection. # Local files Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/local-files Download Knowledge Graph data as JSONL files. Get nodes and relationships exports by direct link or curl for local querying and offline analysis. ## Overview Knowledge Graph data can be downloaded as 2 newline-delimited JSONL files with UTF-8 encoding: * `nodes.jsonl` - Contains Knowledge Graph [entities](/knowledge-graph/understanding-knowledge-graph/core-concepts#entities) (graph nodes) * `relationships.jsonl` - Contains Knowledge Graph [relationships](/knowledge-graph/understanding-knowledge-graph/core-concepts#relationships) (graph edges) ## Download You can download all data in the Knowledge Graph using the following methods: * Direct links - [`nodes.jsonl`](https://cdn.learningcommons.org/knowledge-graph/v1.13.0/exports/nodes.jsonl?ref=docs) ↗ and [`relationships.jsonl`](https://cdn.learningcommons.org/knowledge-graph/v1.13.0/exports/relationships.jsonl?ref=docs) ↗ * [`curl`](https://github.com/curl/curl) ↗ commands ```bash For entities theme={null} curl -L "https://cdn.learningcommons.org/knowledge-graph/v1.13.0/exports/nodes.jsonl?ref=docs_curl" -o nodes.jsonl ``` ```bash For relationships theme={null} curl -L "https://cdn.learningcommons.org/knowledge-graph/v1.13.0/exports/relationships.jsonl?ref=docs_curl" -o relationships.jsonl ``` ## Related topics Learn how entities, relationships, and UUIDs appear in the JSONL files. Compare local files with other ways to get started with Knowledge Graph. # MCP server Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/mcp-server Set up the Knowledge Graph MCP server so AI assistants can resolve standards, unpack learning components, and trace progressions with structured data. The Knowledge Graph MCP Server implements the [Model Context Protocol](https://modelcontextprotocol.io/docs/getting-started/intro) ↗ for K-12 educational data. Instead of relying on model recall, the MCP Server relies on [tools](https://modelcontextprotocol.io/docs/learn/server-concepts#tools) ↗ and structured Knowledge Graph data to: * Resolve [standards](/knowledge-graph/schema-reference/standards) * Deconstruct them into granular [learning components](/knowledge-graph/schema-reference/learning-components) * Trace [learning progressions](/knowledge-graph/schema-reference/learning-progressions) across standards ## What you'll need * MCP Server URL: ```text theme={null} https://kg.mcp.learningcommons.org/mcp ``` * [API keys generated in the Learning Commons Platform](https://platform.learningcommons.org/api-keys) ↗ to include in your request headers for authentication: ```text theme={null} x-api-key: YOUR_API_KEY ``` or ``` Authorization: Bearer YOUR_API_KEY ``` If using an SDK, verify how to pass in the MCP authorization key for your client. ## Steps ```text .env theme={null} OPENAI_API_KEY=sk-... MCP_AUTH_KEY=your_learning_commons_api_key MCP_SERVER_URL=https://kg.mcp.learningcommons.org/mcp ``` Make a request to the MCP server with your question — for example, asking about skills and unfinished learning for California standard `4.OA.A.3`: ```python Python theme={null} import os import requests from dotenv import load_dotenv load_dotenv() openai_api_key = os.getenv("OPENAI_API_KEY") mcp_server_url = os.getenv("MCP_SERVER_URL") mcp_auth_key = os.getenv("MCP_AUTH_KEY") input_prompt = "I am a 4th grade teacher in California. A new student in my class is struggling with the concepts related to 4.OA.A.3. What are the skills required for mastery and what potential unfinished learning should I address?" response = requests.post( "https://api.openai.com/v1/responses", headers={ "Content-Type": "application/json", "Authorization": f"Bearer {openai_api_key}", }, json={ "model": "gpt-4o", "tools": [ { "type": "mcp", "server_label": "learning-commons-kg", "server_url": mcp_server_url, "require_approval": "never", "headers": { "x-api-key": mcp_auth_key } } ], "input": input_prompt } ) print(response.status_code) for item in response.json()["output"]: if item["type"] == "mcp_call": print(f"Tool called: {item['name']}") print(f"Arguments: {item['arguments']}") print(f"Result: {item['output']}") elif item["type"] == "message": print(f"Answer: {item['content'][0]['text']}") ``` ```javascript JavaScript theme={null} import "dotenv/config"; const openaiApiKey = process.env.OPENAI_API_KEY; const mcpServerUrl = process.env.MCP_SERVER_URL; const mcpAuthKey = process.env.MCP_AUTH_KEY; const inputPrompt = "I am a 4th grade teacher in California. A new student in my class is struggling with the concepts related to 4.OA.A.3. What are the skills required for mastery and what potential unfinished learning should I address?"; async function main() { const response = await fetch("https://api.openai.com/v1/responses", { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${openaiApiKey}`, }, body: JSON.stringify({ model: "gpt-4o", tools: [ { type: "mcp", server_label: "learning-commons-kg", server_url: mcpServerUrl, require_approval: "never", headers: { "x-api-key": mcpAuthKey, }, }, ], input: inputPrompt, }), }); const data = await response.json(); console.log(response.status); for (const item of data.output) { if (item.type === "mcp_call") { console.log(`Tool called: ${item.name}`); console.log(`Arguments: ${item.arguments}`); console.log(`Result: ${item.output}`); } else if (item.type === "message") { console.log(`Answer: ${item.content[0].text}`); } } } main(); ``` Your AI client will call Knowledge Graph MCP tools to return structured results (e.g., [standards](/knowledge-graph/schema-reference/standards), [learning components](/knowledge-graph/schema-reference/learning-components), or [learning progressions](/knowledge-graph/schema-reference/learning-progressions)). Inspect `mcp_call` output entries for tool names, arguments, and results. ## Tools Please review the [Knowledge Graph License](/knowledge-graph/resources/license) before using these tools. The MCP server contains the following [tools](https://modelcontextprotocol.io/docs/learn/server-concepts#tools) ↗, which can be used individually or in sequence: | Tool | Description | | :------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------ | | **Find standard statement** | Resolves an education standard code into its authoritative statement and metadata, optionally scoped to a jurisdiction | | **Find learning components from standard** | Breaks a broad standard down into granular Learning Components that represent individual teachable skills | | **Find learning progressions from standard** | Identifies prior or subsequent standards in a learning progression, based on the Student Achievement Partners (SAP) Coherence Map for Mathematics | A common workflow may use all 3 tools: * Resolving a standard code to its official statement * Retrieving the associated learning components for targeted instruction * Tracing progressions to identify prior or follow-on standards ### Inputs
Tool Field Type Required Description
**Find standard statement** statementCode string ✓ e.g., RI.5.2 or 8.F.B.4
jurisdiction string Jurisdiction where standard is adopted (e.g., Maryland)
**Find learning components from standard** caseIdentifierUUID string ✓ UUID of the standard in the CASE Network
**Find learning progressions from standard** caseIdentifierUUID string ✓ UUID of the standard in the CASE Network
direction string ✓ backward for prerequisites and forward for subsequent
## Related topics Set up MCP access and try your first Knowledge Graph requests. # REST API Source: https://docs.learningcommons.org/knowledge-graph/using-knowledge-graph/rest-api Use the Knowledge Graph REST API for programmatic access to academic standards, learning components, learning progressions, and curriculum data. The Knowledge Graph API provides programmatic access to: * [Standards](/knowledge-graph/schema-reference/standards) * [Learning components](/knowledge-graph/schema-reference/learning-components) * [Learning progressions](/knowledge-graph/schema-reference/learning-progressions) * [Curriculum](/knowledge-graph/schema-reference/curriculum) See the [API reference](/api-reference/platform-api/overview) to get started. ## Related topics Browse endpoints, parameters, and response schemas for Knowledge Graph. Follow a step-by-step tutorial to query frameworks and tag content. # Introduction Source: https://docs.learningcommons.org/learning-commons-platform/introduction Get API keys, explore Knowledge Graph datasets, and try Evaluators in the Learning Commons Platform — the home base for Learning Commons developer tools. The [Learning Commons Platform](https://platform.learningcommons.org/) ↗ is your home base for accessing Learning Commons developer tools. ## What the Platform does [Sign up for a free account](https://platform.learningcommons.org/) ↗ to get started: | | | | :--------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**API keys**](https://platform.learningcommons.org/api-keys) ↗ | Create and manage API keys for your organization to authenticate requests to the Knowledge Graph [REST API](/knowledge-graph/using-knowledge-graph/rest-api) and [MCP server](/knowledge-graph/using-knowledge-graph/mcp-server). | | [**Knowledge Graph Explorer**](https://platform.learningcommons.org/apps/knowledge-graph/explorer) ↗ | See how our educational datasets (e.g., [standards](/knowledge-graph/schema-reference/standards), [learning components](/knowledge-graph/schema-reference/learning-components), [learning progressions](/knowledge-graph/schema-reference/learning-progressions), etc.) connect to each other. | | [**Evaluators playground**](https://platform.learningcommons.org/apps/evaluators/playground) ↗ | Get a quick demo of how [Evaluators](/evaluators) work without setting up an [SDK](/evaluators/sdk-api-reference/overview). | ## How to configure the Platform | | | | :------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [**Organization**](http://platform.learningcommons.org/settings/organization) ↗ | Edit [organization](/learning-commons-platform/organizations) details | | [**Team**](http://platform.learningcommons.org/settings/team) ↗ | View organization members, and manage [user roles](/learning-commons-platform/user-roles) and [invitations](/learning-commons-platform/organizations#invitations) | | [**Profile**](http://platform.learningcommons.org/settings/profile) ↗ | Edit your user profile details | ## Related topics Create, view, and revoke API keys for your organization. See how educational datasets like standards and learning components connect. Get a quick demo of evaluators without setting up an SDK. Edit organization details, manage team members, and update your profile. # Organizations Source: https://docs.learningcommons.org/learning-commons-platform/organizations How to invite teammates, accept or cancel invitations, remove members, and manage your Learning Commons Platform organization settings. ## Overview The [Learning Commons Platform](https://platform.learningcommons.org/) ↗ uses organizations to scope [user roles](/learning-commons-platform/user-roles), API keys, and access to gated datasets. An organization can contain many users, and a user can belong to multiple organizations. | Signing up | You will be prompted to: | | :------------------------------ | :-------------------------------------------------------------------------------------------------------------------- | | **Without an email invitation** | Create your own organization as an **Admin** | | **From an email invitation** | [Accept an **Admin**'s invitation](#accept-invitation) to join the existing organization with your assigned user role | ## Invitations Admin only Navigate to [**Settings → Team**](http://platform.learningcommons.org/settings/team) ↗ and click **Invite**. Enter one or more email addresses, separated by commas or new lines. Duplicate or blank entries are ignored. Assign [**Collaborator**](/learning-commons-platform/user-roles) or [**Admin**](/learning-commons-platform/user-roles). The invitee joins with that role when they accept. Confirm that all invitees belong to your team and are authorized to join your organization before clicking **Send**. * Invalid email formats are not accepted * You cannot invite an email that is already an active member or already has a pending invite * Invitations expire after 7 days Each unique address appears in [**Settings → Team**](http://platform.learningcommons.org/settings/team) ↗ with a **Pending** status, and each invitee receives an invitation email with a link. | Invitation state | What happens | | :--------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Expired** | The invite is more than 7 days old. An expired message is shown; there is no Accept action — only a way to continue to the app. | | **Canceled** | An Admin revoked the pending invite. A canceled message is shown; the invite can no longer be accepted. | | **Wrong email** | You are signed in as a different email than the invite. Choose **Continue to app** (abandon the invite) or **Use different email** (signs you out so you can sign in with the correct account). | Everyone Users can belong to more than one organization. If you accept an invite to a second organization, you will be added to that organization without being removed from your first organization. ### Existing users See all pending invitations in a banner at the top of your [Learning Commons Platform](https://platform.learningcommons.org/) ↗ account. For each invitation, review the organization name, who invited you, and your assigned user role before clicking **Accept invitation**. ### New users Click the link in the invitation email. You will be redirected to [Learning Commons Platform](https://platform.learningcommons.org/) ↗ and prompted to create an account. Review the organization name, who invited you, and your assigned user role. If all details look correct, click **Accept invitation**. Admin only Navigate to [**Settings → Team**](http://platform.learningcommons.org/settings/team) ↗ and find a row with **Pending** status. Open the row's menu and click **Cancel invite**. ## Other actions An organization must always keep at least one [**Admin**](/learning-commons-platform/user-roles): * You cannot demote or remove the last **Admin** * If you are the last **Admin**, you cannot leave the organization Admin only
  • Navigate to [**Settings → Team**](http://platform.learningcommons.org/settings/team) ↗
  • Use the row menu for any active user to **Remove** them from the organization
Everyone
  • Navigate to [**Settings → Team**](http://platform.learningcommons.org/settings/team) ↗
  • Use your row menu to **Leave organization**
 Admin only
  • Navigate to [**Settings → Organization**](http://platform.learningcommons.org/settings/organization) ↗
  • Click **Delete organization** and confirm
 ## Related topics Learn about Admin and Collaborator permissions in your organization. Edit organization details or delete your organization. View members and manage roles for your currently selected organization. # User roles Source: https://docs.learningcommons.org/learning-commons-platform/user-roles Compare Admin and Collaborator permissions for organizations and API keys in the Learning Commons Platform, including role management rules. [Learning Commons Platform](https://platform.learningcommons.org/) ↗ users are grouped into [organizations](/learning-commons-platform/organizations) and assigned a user role – **Admin** or **Collaborator**. ## Overview User roles are scoped to an organization and come with their own unique [permissions](#permissions). For example, you can be an **Admin** in Org A and a **Collaborator** in Org B – this means you will be able to invite users to Org A, but not to Org B. An organization can include multiple **Admins** and multiple **Collaborators**. An organization must have at least one **Admin** at all times. ## Permissions ### For organizations | | | | :---------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------- | | [View your organization's users and roles](http://platform.learningcommons.org/settings/team) ↗ | Everyone | | [Edit your organization](http://platform.learningcommons.org/settings/organization) ↗ | Admin only | | [Edit user roles in your organization](http://platform.learningcommons.org/settings/team) ↗ | Admin only | | [Invite users to your organization](/learning-commons-platform/organizations#send-invitation) | Admin only | | [Cancel invitations to your organization](/learning-commons-platform/organizations#cancel-invitation) | Admin only | | [Remove users from your organization](/learning-commons-platform/organizations#remove-user) | Admin only | | [Leave an organization](/learning-commons-platform/organizations#leave-organization) | Everyone
*(Unless you are the only **Admin**)* | | [Delete an organization](/learning-commons-platform/organizations#delete-organization) | Admin only | ### For API keys | | | | :-------------------------------------------------------------------------------------- | :------------------------ | | [View your organization's API keys](http://platform.learningcommons.org/api-keys) ↗ | Everyone | | [Create API keys for your organization](http://platform.learningcommons.org/api-keys) ↗ | Admin only | | [Revoke your organization's API keys](http://platform.learningcommons.org/api-keys) ↗ | Admin only | ## Related topics Invite teammates, accept invitations, and manage members in your organization. View members and manage roles for your currently selected organization. Create, view, and revoke API keys for your organization.