- Home
- Skills
- Agents & Orchestration
- language tutor app builder, build your own duolingo
language tutor app builder, build your own duolingo
Builds voice-first language learning apps with strict pedagogical correction and local LLM integration.
$2.99
Works with the AI Agents you already use
language tutor app builder, build your own duolingo
Example session with this skill installed
Scaffold a German language tutor app using React, Ollama for the backend, and a strict correction workflow for A2 level learners.
- Read your context and instructions
- Compiled the language tutor app
I have scaffolded the German Language Tutor application. The project includes a continuous voice loop, a strict JSON-based correction engine, and local model connectors targeting your Ollama instance.
Language Tutor Project Structure
// src/services/promptBuilder.ts
export const getSystemPrompt = (level: string, goal: string) => `
You are a warm, highly disciplined 1-on-1 language tutor for German.
Learner level: ${level}. Goal: ${goal}.
RULES:
1. STRICT CORRECTION: Inspect grammar, cases (Nominativ, Akkusativ, Dativ), and word order.
2. If error: Set "has_error": true, provide "corrected_text", and "explanation" in English.
3. If no error: Set "has_error": false, provide "validation".
4. Output STRICT JSON ONLY.
`;
// src/types/tutor.ts
export interface TutorCorrection {
has_error: boolean;
original_text: string;
corrected_text: string;
error_category: string;
explanation: string;
phonetic_tip: string;
spoken_response: string;
followup_question: string;
}
// src/hooks/useVoiceLoop.ts
// Orchestrates: Mic -> STT -> Local LLM (Ollama) -> TTS
export const useVoiceLoop = () => {
const processUtterance = async (text: string) => {
const response = await fetch('http://localhost:11434/v1/chat/completions', {
method: 'POST',
body: JSON.stringify({
model: 'qwen2.5:7b',
messages: [{ role: 'system', content: getSystemPrompt('A2', 'Travel') }, { role: 'user', content: text }],
response_format: { type: 'json_object' }
})
});
const data = await response.json();
return JSON.parse(data.choices[0].message.content) as TutorCorrection;
};
return { processUtterance };
};
Next steps
- Start your local Ollama server using
ollama serve. - Run
npm installto install dependencies for the Web Audio API visualizer. - Update the
LOCAL_MODEL_NAMEin.envto match your downloaded model weights.
Connects securely to your tools. The creator never sees your data.
About this skill
Most language learning apps gloss over grammar errors to keep users engaged. This skill builds a production-grade, voice-first tutor that prioritizes strict pedagogical correction using local LLMs. It delivers a deterministic five-stage voice loop that captures audio, transcribes it, evaluates it against grammatical rules, logs mistakes, and responds via high-quality speech synthesis.
What it does
- Continuous voice loop implements a 5-stage pipeline from audio capture and VAD to neural TTS playback.
- Strict correction engine enforces a decision tree that flags grammatical, lexical, and phonetic errors with structured JSON feedback.
- Local LLM integration connects to Ollama, llama.cpp, or LM Studio, specifically targeting model weights stored in local directories.
- Learner state management tracks proficiency levels, learning goals, and a persistent mistake log for long-term review.
- Multi-mode interaction supports both push-to-talk for low latency and hands-free continuous voice activity detection.
How it works
- Scaffold project by generating a modular React/TypeScript architecture with dedicated hooks for voice orchestration and model connectors.
- Configure local inference by setting environment variables for model endpoints and local document paths for weights.
- Implement correction prompts using the provided system templates to ensure the LLM returns strict JSON with explanations and phonetic tips.
- Deploy voice services using Web Speech API or local Whisper fallbacks for STT and browser-native or local neural TTS for speech.
Frameworks & tools
Built for React and TypeScript ecosystems. Integrates with Web Audio API, MediaRecorder, and Web Speech API. Supports local inference servers including Ollama, llama.cpp, and LM Studio.
Why this beats prompting it yourself
Writing a simple prompt often results in "chatty" AI that ignores minor tense or case errors. This skill provides a specialized system architecture that forces structured evaluation, ensuring every grammatical slip is caught, explained, and logged for the user.
Use cases
- Build a private, offline language tutor that doesn't send voice data to external APIs.
- Create a specialized grammar drill app that focuses on specific language cases like German Dativ or Akkusativ.
- Develop a voice-first interface for existing language learning platforms.
- Prototyping high-fidelity CALL (Computer-Assisted Language Learning) applications with local neural speech.
Known limitations
Requires a locally running inference server (Ollama, etc.) and specific browser support for Web Speech APIs. Accuracy is dependent on the selected local model's reasoning capabilities.
Requires local inference server (Ollama/llama.cpp). Browser-native STT/TTS quality varies by OS. Best performance requires models with 7B+ parameters.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 8 days ago