language tutor app builder, build your own duolingo

    1

    Builds voice-first language learning apps with strict pedagogical correction and local LLM integration.

    $2.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    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

    1. Start your local Ollama server using ollama serve.
    2. Run npm install to install dependencies for the Web Audio API visualizer.
    3. Update the LOCAL_MODEL_NAME in .env to 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

    1. Scaffold project by generating a modular React/TypeScript architecture with dedicated hooks for voice orchestration and model connectors.
    2. Configure local inference by setting environment variables for model endpoints and local document paths for weights.
    3. Implement correction prompts using the provided system templates to ensure the LLM returns strict JSON with explanations and phonetic tips.
    4. 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Environment Variables
    Listed8 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard LLM prompts that prioritize conversational flow, this skill implements a strict, five-stage pedagogical loop that enforces grammatical rules and logs every error for student review. It prevents the AI from 'glossing over' mistakes, ensuring a rigorous learning environment similar to a professional human tutor.

    This skill is designed for React and TypeScript environments and is optimized for use with local inference servers like Ollama, llama.cpp, or LM Studio. It is compatible with any AI agent framework that supports local LLM endpoints and browser-based voice APIs.

    You will receive a complete scaffolding package including a modular React/TypeScript architecture, specialized system templates for JSON-based feedback, and dedicated hooks for managing voice orchestration and local model connectors.

    Yes, the builder is specifically designed to work with local LLM weights (via Ollama or llama.cpp) and can utilize local Whisper fallbacks for speech-to-text. This allows you to build a fully functional language tutor that operates entirely offline without sending voice data to external APIs.

    The builder includes a robust Learner State Management system that tracks user proficiency levels and maintains a persistent mistake log. This allows the tutor to reference past errors and adapt the difficulty of the conversation over multiple sessions.

    New in Agents & Orchestration