Build Your AI Language Tutor: Complete Ollama Multilingual Education Assistant Setup Guide

curl -fsSL https://ollama.ai/install.sh | sh

ollama --version
# Should output: ollama version 0.1.x

# Primary model - excellent for conversations
ollama pull llama2:13b

# Specialized for code-switching and grammar
ollama pull codellama:7b

# Lightweight model for quick responses
ollama pull llama2:7b

# Excellent for European languages
ollama pull mistral:7b

# Strong performance with Asian languages
ollama pull vicuna:13b

mkdir ollama-language-tutor
cd ollama-language-tutor
touch language-config.json

{
  "learner_profile": {
    "native_language": "English",
    "target_languages": ["Spanish", "French", "German"],
    "proficiency_levels": {
      "Spanish": "intermediate",
      "French": "beginner", 
      "German": "advanced"
    },
    "learning_goals": ["conversation", "grammar", "pronunciation"]
  },
  "session_settings": {
    "correction_style": "gentle",
    "cultural_context": true,
    "pronunciation_tips": true,
    "vocabulary_tracking": true
  },
  "model_preferences": {
    "primary": "llama2:13b",
    "fallback": "llama2:7b",
    "specialized": "mistral:7b"
  }
}

#!/usr/bin/env python3
"""
Ollama Multilingual Education Assistant
Interactive language learning with AI conversation partner
"""

import json
import requests
import sys
from datetime import datetime

class OllamaLanguageTutor:
    def __init__(self, config_file='language-config.json'):
        """Initialize the language tutor with user configuration"""
        with open(config_file, 'r') as f:
            self.config = json.load(f)
        
        self.base_url = "http://localhost:11434/api/generate"
        self.current_language = None
        self.session_history = []
    
    def set_language(self, language):
        """Switch to a specific target language"""
        if language in self.config['learner_profile']['target_languages']:
            self.current_language = language
            level = self.config['learner_profile']['proficiency_levels'][language]
            print(f"🌍 Switched to {language} (Level: {level})")
            return True
        else:
            print(f"❌ {language} not in your learning languages")
            return False
    
    def generate_prompt(self, user_input, mode='conversation'):
        """Create contextual prompts based on learning mode"""
        native = self.config['learner_profile']['native_language']
        target = self.current_language
        level = self.config['learner_profile']['proficiency_levels'][target]
        
        base_prompt = f"""You are a helpful {target} language tutor. 
        Student's native language: {native}
        Student's {target} level: {level}
        
        Instructions:
        - Respond primarily in {target}
        - Provide translations when helpful
        - Correct mistakes gently
        - Explain grammar when relevant
        - Include cultural context
        
        Student says: "{user_input}"
        
        Respond as a patient tutor:"""
        
        if mode == 'grammar':
            base_prompt += f"\nFocus on grammar analysis and corrections."
        elif mode == 'vocabulary':
            base_prompt += f"\nTeach new vocabulary related to the topic."
        elif mode == 'culture':
            base_prompt += f"\nExplain cultural context and usage."
            
        return base_prompt
    
    def chat_with_tutor(self, user_input, mode='conversation'):
        """Send message to Ollama and get tutor response"""
        if not self.current_language:
            return "Please select a target language first using set_language()"
        
        prompt = self.generate_prompt(user_input, mode)
        
        payload = {
            "model": self.config['model_preferences']['primary'],
            "prompt": prompt,
            "stream": False
        }
        
        try:
            response = requests.post(self.base_url, json=payload)
            response.raise_for_status()
            
            result = response.json()
            tutor_response = result['response']
            
            # Track conversation for session summary
            self.session_history.append({
                'timestamp': datetime.now().isoformat(),
                'user_input': user_input,
                'tutor_response': tutor_response,
                'language': self.current_language,
                'mode': mode
            })
            
            return tutor_response
            
        except requests.exceptions.RequestException as e:
            return f"Error connecting to Ollama: {e}"
    
    def practice_conversation(self):
        """Interactive conversation practice mode"""
        print(f"🗣️  Starting conversation practice in {self.current_language}")
        print("Type 'quit' to exit, 'help' for commands\n")
        
        while True:
            user_input = input(f"You ({self.current_language}): ").strip()
            
            if user_input.lower() == 'quit':
                break
            elif user_input.lower() == 'help':
                self.show_help()
                continue
            elif user_input.lower().startswith('/grammar'):
                response = self.chat_with_tutor(user_input[8:], 'grammar')
            elif user_input.lower().startswith('/vocab'):
                response = self.chat_with_tutor(user_input[6:], 'vocabulary')
            elif user_input.lower().startswith('/culture'):
                response = self.chat_with_tutor(user_input[8:], 'culture')
            else:
                response = self.chat_with_tutor(user_input)
            
            print(f"Tutor: {response}\n")
    
    def show_help(self):
        """Display available commands"""
        help_text = """
        Available commands:
        - /grammar [text] - Focus on grammar analysis
        - /vocab [text] - Learn vocabulary 
        - /culture [text] - Cultural context
        - help - Show this message
        - quit - Exit practice session
        """
        print(help_text)
    
    def session_summary(self):
        """Generate learning session summary"""
        if not self.session_history:
            return "No practice session recorded"
        
        summary_prompt = f"""Analyze this language learning session and provide:
        1. Key vocabulary learned
        2. Grammar points covered  
        3. Areas for improvement
        4. Recommended next steps
        
        Session data: {json.dumps(self.session_history[-10:], indent=2)}
        """
        
        return self.chat_with_tutor(summary_prompt, 'summary')

# Usage example
if __name__ == "__main__":
    tutor = OllamaLanguageTutor()
    
    # Set target language
    tutor.set_language("Spanish")
    
    # Start interactive practice
    tutor.practice_conversation()

chmod +x language_tutor.py

# Ensure Ollama is running
ollama serve &

# Launch your language tutor
python3 language_tutor.py

def get_optimal_model(self, language, task):
    """Select best model based on language and task"""
    model_routing = {
        'Spanish': 'llama2:13b',    # Excellent Spanish performance
        'French': 'mistral:7b',     # Strong French capabilities  
        'German': 'vicuna:13b',     # Good German grammar understanding
        'Chinese': 'llama2:13b',    # Handles Chinese characters well
        'Japanese': 'codellama:7b', # Good with complex scripts
    }
    
    if task == 'grammar':
        return 'codellama:7b'  # Best for structural analysis
    elif task == 'conversation':
        return model_routing.get(language, 'llama2:13b')
    else:
        return self.config['model_preferences']['primary']

def track_vocabulary(self, new_words, language):
    """Track learned vocabulary across sessions"""
    vocab_file = f"vocabulary_{language.lower()}.json"
    
    try:
        with open(vocab_file, 'r') as f:
            vocab_data = json.load(f)
    except FileNotFoundError:
        vocab_data = {"words": {}, "last_updated": ""}
    
    for word in new_words:
        vocab_data["words"][word] = {
            "learned_date": datetime.now().isoformat(),
            "review_count": 0,
            "mastery_level": "learning"
        }
    
    vocab_data["last_updated"] = datetime.now().isoformat()
    
    with open(vocab_file, 'w') as f:
        json.dump(vocab_data, f, indent=2)

import speech_recognition as sr
import pyttsx3

def setup_voice_practice(self):
    """Enable speech recognition and text-to-speech"""
    self.recognizer = sr.Recognizer()
    self.microphone = sr.Microphone()
    self.tts = pyttsx3.init()
    
    # Configure TTS for target language
    voices = self.tts.getProperty('voices')
    for voice in voices:
        if self.current_language.lower() in voice.name.lower():
            self.tts.setProperty('voice', voice.id)
            break

def practice_pronunciation(self, text):
    """Practice pronunciation with feedback"""
    print(f"🎤 Repeat after me: {text}")
    self.tts.say(text)
    self.tts.runAndWait()
    
    with self.microphone as source:
        self.recognizer.adjust_for_ambient_noise(source)
        print("🎤 Listening...")
        audio = self.recognizer.listen(source)
    
    try:
        spoken_text = self.recognizer.recognize_google(
            audio, 
            language=self.get_language_code()
        )
        return self.compare_pronunciation(text, spoken_text)
    except sr.UnknownValueError:
        return "Could not understand audio. Try again?"

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "language_tutor.py", "--server-mode"]

docker build -t ollama-language-tutor .
docker run -p 8000:8000 ollama-language-tutor

from flask import Flask, render_template, request, jsonify

app = Flask(__name__)
tutor = OllamaLanguageTutor()

@app.route('/')
def index():
    return render_template('language_tutor.html')

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_input = data['message']
    language = data['language']
    mode = data.get('mode', 'conversation')
    
    tutor.set_language(language)
    response = tutor.chat_with_tutor(user_input, mode)
    
    return jsonify({'response': response})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=8000)

# Verify available models
ollama list

# Re-download if missing
ollama pull llama2:13b

# Check disk space
df -h

def optimize_memory_usage(self):
    """Configure model for lower memory usage"""
    self.model_config = {
        "num_ctx": 2048,      # Reduce context window
        "num_batch": 512,     # Smaller batch size
        "num_gpu": 0,         # Use CPU only if needed
        "low_vram": True      # Enable low VRAM mode
    }

def enforce_language_consistency(self, response, target_language):
    """Ensure AI responds in target language"""
    if not self.contains_target_language(response, target_language):
        correction_prompt = f"""Please respond to the previous message 
        primarily in {target_language}. Original response: {response}"""
        
        return self.chat_with_tutor(correction_prompt)
    return response

def optimize_response_time(self):
    """Configure for faster responses"""
    return {
        "temperature": 0.7,     # Balanced creativity/speed
        "top_p": 0.9,          # Focused response generation
        "repeat_penalty": 1.1,  # Avoid repetition
        "max_tokens": 150       # Limit response length
    }

def generate_progress_report(self, days=7):
    """Generate learning progress report"""
    recent_sessions = self.get_recent_sessions(days)
    
    metrics = {
        'total_conversations': len(recent_sessions),
        'languages_practiced': set(s['language'] for s in recent_sessions),
        'new_vocabulary': self.count_new_vocabulary(recent_sessions),
        'grammar_improvements': self.analyze_grammar_progress(recent_sessions),
        'conversation_length_trend': self.calculate_length_trend(recent_sessions)
    }
    
    return self.format_progress_report(metrics)

def spaced_repetition_quiz(self):
    """Generate vocabulary quiz based on spaced repetition"""
    due_words = self.get_due_vocabulary_review()
    
    quiz_data = []
    for word in due_words:
        quiz_data.append({
            'word': word,
            'context': self.get_word_context(word),
            'difficulty': self.calculate_word_difficulty(word)
        })
    
    return self.generate_quiz_questions(quiz_data)

def add_cultural_context(self, phrase, language):
    """Provide cultural context for expressions"""
    cultural_prompt = f"""Explain the cultural context of "{phrase}" 
    in {language}-speaking countries. Include:
    - When/where it's commonly used
    - Cultural significance
    - Regional variations
    - Similar expressions in other cultures"""
    
    return self.chat_with_tutor(cultural_prompt, 'culture')

def analyze_grammar_patterns(self, user_text):
    """Identify and explain grammar patterns"""
    analysis_prompt = f"""Analyze the grammar in: "{user_text}"
    
    Provide:
    1. Sentence structure breakdown
    2. Verb tenses used
    3. Common patterns demonstrated
    4. Improvement suggestions
    5. Similar sentence examples"""
    
    return self.chat_with_tutor(analysis_prompt, 'grammar')

def export_to_anki(self, vocabulary_list):
    """Export learned vocabulary to Anki format"""
    anki_cards = []
    
    for word_data in vocabulary_list:
        card = {
            'front': word_data['word'],
            'back': f"{word_data['translation']}\n{word_data['example']}",
            'tags': [self.current_language, 'ollama-tutor']
        }
        anki_cards.append(card)
    
    return self.save_anki_deck(anki_cards)

def simulate_language_exchange(self, partner_language, topic):
    """Simulate conversation with native speaker"""
    exchange_prompt = f"""Act as a native {partner_language} speaker 
    interested in learning {self.config['learner_profile']['native_language']}.
    
    Topic: {topic}
    
    - Use natural {partner_language} expressions
    - Ask questions about my culture
    - Make small mistakes in English for realism
    - Share cultural insights about {partner_language}-speaking countries"""
    
    return self.chat_with_tutor(exchange_prompt, 'exchange')

def backup_learning_data(self):
    """Backup all learning progress and vocabulary"""
    backup_data = {
        'config': self.config,
        'session_history': self.session_history,
        'vocabulary': self.load_all_vocabulary_files(),
        'progress_metrics': self.get_progress_metrics(),
        'backup_timestamp': datetime.now().isoformat()
    }
    
    backup_file = f"language_learning_backup_{datetime.now().strftime('%Y%m%d')}.json"
    
    with open(backup_file, 'w') as f:
        json.dump(backup_data, f, indent=2)
    
    return f"Learning data backed up to {backup_file}"