@gebrai/gebrai
Version:
Model Context Protocol server for GeoGebra mathematical visualization
259 lines • 10.5 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.educationalTemplateTools = exports.templateRegistry = exports.EducationalTemplateRegistry = void 0;
exports.initializeEducationalTemplates = initializeEducationalTemplates;
const index_1 = require("./index");
const logger_1 = __importDefault(require("../utils/logger"));
/**
* Educational Templates for GeoGebra MCP Tool - GEB-8 Implementation
*
* Pre-built mathematical scenarios for common educational use cases:
* - Geometry fundamentals
* - Algebra visualizations
* - Calculus demonstrations
* - Statistics and probability
* - Mathematical proofs
*/
// Check if we're in MCP mode (stdio communication)
// When piping input, process.stdin.isTTY is undefined, not false
const isMcpMode = !process.stdin.isTTY;
/**
* Educational template registry
*/
class EducationalTemplateRegistry {
templates = new Map();
register(template) {
this.templates.set(template.id, template);
if (!isMcpMode) {
logger_1.default.info(`Registered educational template: ${template.id}`);
}
}
getTemplate(id) {
return this.templates.get(id);
}
getTemplatesByCategory(category) {
return Array.from(this.templates.values()).filter(t => t.category === category);
}
getAllTemplates() {
return Array.from(this.templates.values());
}
}
exports.EducationalTemplateRegistry = EducationalTemplateRegistry;
exports.templateRegistry = new EducationalTemplateRegistry();
/**
* Core educational template tools
*/
exports.educationalTemplateTools = [
{
tool: {
name: 'geogebra_list_educational_templates',
description: 'List all available educational templates by category',
inputSchema: {
type: 'object',
properties: {
category: {
type: 'string',
enum: ['geometry', 'algebra', 'calculus', 'statistics', 'proofs'],
description: 'Filter templates by category (optional)'
},
gradeLevel: {
type: 'string',
description: 'Filter by grade level (e.g., "6-8", "9-12", "college")'
}
},
required: []
}
},
handler: async (params) => {
const { category, gradeLevel } = params;
let templates = exports.templateRegistry.getAllTemplates();
if (category) {
templates = templates.filter(t => t.category === category);
}
if (gradeLevel) {
templates = templates.filter(t => t.gradeLevel === gradeLevel);
}
const templateList = templates.map(template => ({
id: template.id,
name: template.name,
category: template.category,
description: template.description,
gradeLevel: template.gradeLevel,
estimatedTime: template.estimatedTime,
objectives: template.objectives
}));
return {
content: [{
type: 'text',
text: JSON.stringify({
success: true,
count: templateList.length,
templates: templateList
}, null, 2)
}]
};
}
},
{
tool: {
name: 'geogebra_load_educational_template',
description: 'Load and execute a specific educational template',
inputSchema: {
type: 'object',
properties: {
templateId: {
type: 'string',
description: 'The ID of the educational template to load'
},
customizations: {
type: 'object',
description: 'Optional customizations for the template (colors, parameters, etc.)',
properties: {
colors: {
type: 'object',
description: 'Custom color scheme'
},
parameters: {
type: 'object',
description: 'Custom parameter values'
},
showLabels: {
type: 'boolean',
description: 'Whether to show object labels'
}
}
}
},
required: ['templateId']
}
},
handler: async (params) => {
const { templateId } = params;
// Note: customizations parameter is accepted but not yet implemented
// Future enhancement: apply color schemes, parameters, and display options
// const customizations = params['customizations'] || {};
const template = exports.templateRegistry.getTemplate(templateId);
if (!template) {
throw new Error(`Educational template not found: ${templateId}`);
}
logger_1.default.info(`Loading educational template: ${template.name}`);
// Clear existing construction
await index_1.toolRegistry.executeTool('geogebra_clear_construction', {});
// Execute template setup
const result = await template.setup();
return {
content: [{
type: 'text',
text: JSON.stringify({
success: true,
template: {
id: template.id,
name: template.name,
category: template.category,
loaded: true
},
objectives: template.objectives,
instructions: `Template "${template.name}" loaded successfully. Estimated time: ${template.estimatedTime} minutes.`,
result
}, null, 2)
}]
};
}
},
{
tool: {
name: 'geogebra_create_lesson_plan',
description: 'Generate a complete lesson plan using multiple educational templates',
inputSchema: {
type: 'object',
properties: {
topic: {
type: 'string',
description: 'The mathematical topic for the lesson'
},
gradeLevel: {
type: 'string',
description: 'Target grade level'
},
duration: {
type: 'number',
description: 'Lesson duration in minutes'
},
templateIds: {
type: 'array',
items: { type: 'string' },
description: 'Specific template IDs to include in the lesson'
}
},
required: ['topic', 'gradeLevel', 'duration']
}
},
handler: async (params) => {
const { topic, gradeLevel, duration, templateIds } = params;
// Auto-select templates if not specified
let selectedTemplates;
if (templateIds && Array.isArray(templateIds)) {
selectedTemplates = templateIds
.map(id => exports.templateRegistry.getTemplate(id))
.filter(Boolean);
}
else {
// Auto-select based on topic and grade level
selectedTemplates = exports.templateRegistry.getAllTemplates()
.filter(t => t.gradeLevel === gradeLevel)
.filter(t => t.estimatedTime <= duration)
.slice(0, 3); // Limit to 3 templates for a lesson
}
const lessonPlan = {
topic,
gradeLevel,
duration,
templates: selectedTemplates.map(t => ({
id: t.id,
name: t.name,
category: t.category,
estimatedTime: t.estimatedTime,
objectives: t.objectives,
prerequisites: t.prerequisites
})),
totalTime: selectedTemplates.reduce((sum, t) => sum + t.estimatedTime, 0),
structure: {
introduction: "5 minutes - Review prerequisites and introduce objectives",
activities: selectedTemplates.map((t, i) => `Activity ${i + 1}: ${t.name} (${t.estimatedTime} min) - ${t.description}`),
conclusion: "5 minutes - Summary and assessment"
}
};
return {
content: [{
type: 'text',
text: JSON.stringify(lessonPlan, null, 2)
}]
};
}
}
];
/**
* Initialize and register all educational templates
*/
function initializeEducationalTemplates() {
// Import templates from different categories
const { geometryTemplates } = require('./templates/geometry-templates');
const { algebraTemplates } = require('./templates/algebra-templates');
// Register geometry templates
geometryTemplates.forEach((template) => {
exports.templateRegistry.register(template);
});
// Register algebra templates
algebraTemplates.forEach((template) => {
exports.templateRegistry.register(template);
});
if (!isMcpMode) {
logger_1.default.info(`Registered ${exports.templateRegistry.getAllTemplates().length} educational templates`);
}
}
// Initialize templates when module is loaded
initializeEducationalTemplates();
//# sourceMappingURL=educational-templates.js.map