Strategy Pattern

Behavioral pattern for dynamic algorithm selection

Overview

Category

Behavioral Design Pattern

Purpose

Encapsulate interchangeable algorithms

---

Problem Statement

The Challenge

The chatbot needs to determine user intent and fetch appropriate context. We needed:

1. Multiple classification algorithms: Keyword matching vs LLM analysis
2. Multiple context sources: Dining, announcements, or general
3. Runtime flexibility: Switch via configuration without code changes

Without Strategy Pattern, we would need complex if-elif chains that violate the Open-Closed Principle.

Why Strategy Pattern?

Alternative	Problem
If-elif chains	Violates OCP, hard to maintain
Inheritance	Tight coupling, less flexible
Strategy Pattern	✅ Encapsulates algorithms, easy to swap

---

Solution 1: Intent Classification

UML Diagram

Code Example

# Abstract Base Class (Strategy Interface)
class IntentClassifier(ABC):
    @abstractmethod
    async def classify(self, message: str) -> str:
        """Returns: 'dining', 'announcement', or 'general'"""
        pass

# Concrete Strategy: Hybrid
class HybridClassifier(IntentClassifier):
    def __init__(self, ollama_classifier, fuzzy_classifier):
        self.ollama = ollama_classifier
        self.fuzzy = fuzzy_classifier

    async def classify(self, message: str) -> str:
        try:
            return await asyncio.wait_for(
                self.ollama.classify(message), timeout=5.0
            )
        except Exception:
            return await self.fuzzy.classify(message)

File Locations

Strategy	File
IntentClassifier	llm_engine/classifiers/base.py
FuzzyClassifier	llm_engine/classifiers/fuzzy_classifier.py
OllamaClassifier	llm_engine/classifiers/ollama_classifier.py
HybridClassifier	llm_engine/classifiers/hybrid_classifier.py

---

Solution 2: Context Fetching

UML Diagram

Code Example

class DiningStrategy(ContextStrategy):
    async def fetch(self, query: str) -> str:
        raw_menus = await fetch_dining_data_raw()
        return self._format_for_llm(raw_menus)
    
    def _format_for_llm(self, menus: List[Dict]) -> str:
        # Turkish localization (BUGÜN, YARIN)
        # Emoji formatting for readability
        return formatted_string

Each Strategy owns its formatting logic. The Service layer returns raw List[Dict], and the Strategy transforms it into an LLM-optimized string.

---

Benefits

Open-Closed Principle

Add new classifiers without modifying existing code

Single Responsibility

Each strategy handles one algorithm

Runtime Flexibility

Switch via .env configuration

Testability

Mock strategies easily in unit tests