No LLM Code in Dependencies: The Complete Guide

Table of Contents

1. Introduction
2. Chapter 1: Fundamentals
3. Chapter 2: Getting Started
4. Chapter 3: Core Techniques
5. Chapter 4: Advanced Strategies
6. Chapter 5: Real-World Case Studies
7. Chapter 6: Common Mistakes & Troubleshooting
8. Chapter 7: Tools & Resources
9. Chapter 8: 30-Day Action Plan
10. Conclusion
11. Appendix: Cheat Sheet

---

Introduction

The integration of Large Language Models (LLMs) into software engineering workflows has shifted from a novelty to a necessity. However, as adoption scales, a critical architectural vulnerability has emerged: the hard-coding of LLM logic directly within application dependencies. This practice—embedding model weights, inference engines, or rigid API call structures directly into the core business logic—is creating technical debt, security liabilities, and maintenance nightmares. This guide addresses a specific, high-value paradigm shift: "No LLM Code in Dependencies."

This is not merely a coding style preference; it is a fundamental architectural imperative for modern, scalable, and secure AI-powered applications. When LLM logic is embedded in dependencies, you create tight coupling between your stable business domain and the volatile, rapidly changing landscape of AI models. You risk version conflicts, dependency bloat, security breaches via prompt injection, and an inability to swap models without refactoring core code. This guide teaches you how to decouple these concerns, creating a resilient architecture where AI capabilities are treated as external services or configurable plugins rather than intrinsic code components.

Who This Guide Is For

This guide is designed for Senior Software Engineers, System Architects, and Technical Leads who are responsible for building production-grade applications that leverage Generative AI. It assumes you have a working knowledge of Python, Java, or Go, and familiarity with REST/gRPC APIs. It is not intended for beginners learning basic syntax, but for professionals facing the reality of maintaining complex systems where AI is a first-class citizen. If you are struggling with pip install times blowing up your build pipeline, or if your CI/CD fails because a specific transformer library version broke a downstream dependency, this guide is for you.

Why This Matters NOW

The AI landscape changes weekly. New models drop, old ones are deprecated, pricing structures shift, and security vulnerabilities in inference libraries are discovered. If your application’s core logic contains direct references to these unstable elements, your stability is compromised. Furthermore, enterprise compliance requirements (GDPR, HIPAA, SOC2) increasingly demand strict control over data flow. Hardcoded LLM dependencies often bypass audit trails, making compliance impossible. By adopting a "No LLM Code in Dependencies" strategy, you future-proof your application, enhance security, and reduce operational overhead.

What You Will Be Able To Do After Reading

By the end of this guide, you will be able to:

1. Architect Decoupled Systems: Design systems where LLM interactions are isolated in dedicated service layers or middleware, leaving business logic clean and testable.
2. Implement Dependency Injection for AI: Use robust patterns to inject model configurations at runtime, allowing hot-swapping of providers (e.g., switching from OpenAI to Anthropic without code changes).
3. Secure AI Integrations: Eliminate hardcoded credentials and mitigate risks associated with embedding large model binaries or inference engines in client-side dependencies.
4. Optimize Build Times & Package Sizes: Remove heavy AI libraries from core dependencies, significantly reducing your application’s footprint and improving deployment speeds.
5. Debug AI Failures Isolated: Create clear boundaries between business logic errors and AI inference errors, simplifying debugging and monitoring.

This guide provides the theoretical framework, practical code examples, and strategic insights needed to implement this architecture. It is structured to take you from foundational concepts to advanced scaling strategies, ensuring you can immediately apply these techniques to your current projects.

---

Chapter 1: Fundamentals

To effectively implement "No LLM Code in Dependencies," we must first understand the problem space deeply. This chapter defines the core concepts, establishes the mental models, and explains why traditional integration methods fail at scale.

The Problem with Tightly Coupled AI

In a typical naive implementation, an application’s business logic might look like this:

# BAD PRACTICE: Tightly Coupled
from transformers import AutoModelForCausalLM, AutoTokenizer

class CustomerServiceBot:
    def __init__(self):
        # Loading a 7B parameter model into memory during initialization
        self.model = AutoModelForCausalLM.from_pretrained("Llama-2-7b")
        self.tokenizer = AutoTokenizer.from_pretrained("Llama-2-7b")

    def answer_question(self, question: str) -> str:
        inputs = self.tokenizer(question, return_tensors="pt")
        outputs = self.model.generate(**inputs)
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

This approach embeds significant code and state into the dependency. The CustomerServiceBot class is now dependent on transformers, torch, and the specific model binary. This creates several issues:

1. Heavy Dependencies: The package size explodes. Including PyTorch or TensorFlow in a microservice that only needs occasional text generation is inefficient.
2. Cold Start Latency: Initializing the model takes seconds to minutes, delaying request processing.
3. Rigidity: Changing the model requires changing the code and redeploying.
4. Security Risks: Embedding models locally can expose proprietary fine-tunes or allow malicious actors to extract model weights if not properly secured.

Core Concepts

1. Separation of Concerns (SoC)

The primary principle is isolating the what (business logic) from the how (AI inference). Business logic should care about user intent, data validation, and workflow orchestration. The AI layer should care about tokenization, model selection, and response parsing. These two domains have different lifecycle requirements. Business logic changes slowly; AI models change frequently. SoC ensures that changes in one do not necessitate rewrites in the other.

2. The Adapter Pattern

The Adapter pattern allows incompatible interfaces to work together. In this context, you create a standardized interface (e.g., IChatProvider) that your business logic depends on. Different implementations (e.g., OpenAIAdapter, LocalLLMAdapter) satisfy this interface. Your business logic calls the interface, never the concrete implementation. This is the cornerstone of removing LLM code from dependencies.

3. Externalization of State

LLM inference often requires state (context windows, session history, model weights). Instead of storing this state within your application’s dependency tree, externalize it. Use Redis for session history, cloud-based APIs for inference, or separate microservices for model management. This keeps your core application lightweight and stateless where possible.

4. Configuration Over Code

Hardcoding model names, API keys, or temperature settings in code is dangerous. Instead, use environment variables or configuration files. This allows you to change behavior without recompiling or repackaging your application.

Key Terminology

• Dependency Injection (DI): A design pattern where an object receives other objects that it depends on, rather than creating them itself. In AI, this means injecting the chat provider instance rather than instantiating it inside the service.
• Interface Segregation: Keeping the AI interface minimal and focused. Don’t force business logic to depend on methods it doesn’t need (e.g., embedding generation if you only need text completion).
• Service Mesh: A dedicated infrastructure layer for handling service-to-service communication. It can manage AI routing, load balancing, and security policies, further decoupling AI logic from business apps.
• Prompt Engineering as Configuration: Treat prompts as data, not code. Store them in databases or version-controlled text files, loaded dynamically by the adapter.

Mental Models

Imagine your application as a restaurant. The kitchen (Business Logic) prepares the meal based on the order. The supplier (LLM Provider) provides the ingredients. If the kitchen builds its own farm (embeds LLM code), it becomes incredibly complex and slow. Instead, the kitchen orders ingredients from a trusted supplier. If the supplier changes prices or quality, the kitchen just updates its contract (Configuration), not its cooking recipes (Business Logic).

Another mental model is the Plugin Architecture. Your application is the host; AI capabilities are plugins. Plugins can be added, removed, or updated without affecting the host’s core functionality. This modularity is essential for scalability.

Real-World Examples

1. E-commerce Search: A search feature uses vector embeddings. Instead of embedding the vector database driver and model loader in the web server, it sends queries to a dedicated search microservice. The web server only handles HTTP requests.
2. Code Review Tool: A GitHub integration analyzes pull requests. Instead of running a local LLM (which is slow and resource-heavy), it sends diffs to an external AI service via API. The integration logic focuses on parsing GitHub events, not running inference.
3. Mobile App Assistant: A mobile app cannot bundle a 7B parameter model due to size constraints. It uses a remote API. The app code contains only network request logic, not model inference code, keeping the APK/IPA small and secure.

Understanding these fundamentals sets the stage for implementing a robust, decoupled architecture. The next chapters will walk you through the practical steps to achieve this.

---

Chapter 2: Getting Started

Transitioning to a decoupled architecture requires careful planning and execution. This chapter guides you through prerequisites, setup, and your first practical implementation of the "No LLM Code in Dependencies" pattern.

Prerequisites

Before proceeding, ensure you have the following:

1. Development Environment: Python 3.9+ (or your preferred language).
2. Package Manager: pip (Python), npm (Node.js), or go mod (Go).
3. API Keys: Access to at least one major LLM provider (e.g., OpenAI, Anthropic, or Azure OpenAI).
4. Version Control: Git repository initialized.
5. Virtual Environment: Tool like venv, conda, or poetry to isolate dependencies.

Step-by-Step Installation and Configuration

We will set up a Python project using the Adapter Pattern and Dependency Injection.

Step 1: Project Structure

Create a new directory and structure it as follows:

ai-decoupled-project/
├── src/
│   ├── adapters/
│   │   ├── __init__.py
│   │   └── openai_adapter.py
│   ├── core/
│   │   ├── __init__.py
│   │   └── chat_service.py
│   ├── config/
│   │   ├── __init__.py
│   │   └── settings.py
│   └── main.py
├── tests/
│   ├── __init__.py
│   └── test_chat_service.py
├── requirements.txt
└── .env

Step 2: Define Settings

Create src/config/settings.py. Use pydantic-settings for robust configuration management.

# src/config/settings.py
from pydantic_settings import BaseSettings
from typing import Optional

class Settings(BaseSettings):
    openai_api_key: str
    model_name: str = "gpt-3.5-turbo"
    max_tokens: int = 1000
    temperature: float = 0.7
    
    class Config:
        env_file = ".env"

settings = Settings()

Ensure your .env file contains:

OPENAI_API_KEY=sk-your-key-here
MODEL_NAME=gpt-3.5-turbo

Install dependencies:

pip install pydantic-settings openai

Step 3: Create the Interface

Define the abstract base class that all adapters must implement. This goes in src/adapters/__init__.py or a separate base.py.

# src/adapters/base.py
from abc import ABC, abstractmethod
from typing import List, Dict

class ChatAdapter(ABC):
    @abstractmethod
    def generate_response(self, messages: List[Dict[str, str]]) -> str:
        pass

Step 4: Implement the Adapter

Create src/adapters/openai_adapter.py. Note that this adapter depends on openai, but the core logic does not.

# src/adapters/openai_adapter.py
import openai
from src.adapters.base import ChatAdapter
from src.config.settings import settings

class OpenAIAdapter(ChatAdapter):
    def generate_response(self, messages: List[Dict[str, str]]) -> str:
        client = openai.OpenAI(api_key=settings.openai_api_key)
        response = client.chat.completions.create(
            model=settings.model_name,
            messages=messages,
            max_tokens=settings.max_tokens,
            temperature=settings.temperature
        )
        return response.choices[0].message.content

Step 5: Implement Core Business Logic

Create src/core/chat_service.py. This is where the magic happens. Notice it imports the interface, not the implementation.

# src/core/chat_service.py
from src.adapters.base import ChatAdapter
from typing import List, Dict

class ChatService:
    def __init__(self, adapter: ChatAdapter):
        # Dependency Injection: The adapter is passed in, not created here
        self.adapter = adapter

    def process_user_query(self, user_message: str) -> str:
        # Business Logic: Validation, logging, etc.
        if not user_message.strip():
            raise ValueError("Message cannot be empty")
        
        messages = [{"role": "user", "content": user_message}]
        
        # Delegate to adapter
        response = self.adapter.generate_response(messages)
        return response

Step 6: Wire It Up

In src/main.py, inject the specific adapter.

# src/main.py
from src.core.chat_service import ChatService
from src.adapters.openai_adapter import OpenAIAdapter

def main():
    # Instantiate the adapter
    openai_adapter = OpenAIAdapter()
    
    # Inject it into the service
    chat_service = ChatService(adapter=openai_adapter)
    
    # Use the service
    result = chat_service.process_user_query("What is the capital of France?")
    print(result)

if __name__ == "__main__":
    main()

First Practical Exercise

Run the application:

python src/main.py

Verify the output. It should print "Paris".

Verification

To verify the decoupling:

1. Check requirements.txt. It should include openai and pydantic-settings.
2. Check src/core/chat_service.py. It should not import openai or pydantic.
3. Modify src/main.py to use a different adapter (we’ll create one in Chapter 3) and run again. The core logic remains unchanged.

This setup demonstrates the fundamental shift: your business logic (ChatService) is agnostic to the underlying AI technology. This is the first step toward a maintainable, scalable AI architecture.

---

Chapter 3: Core Techniques

Now that you have a basic structure, let’s deepen our understanding with core techniques. This chapter explores specific methodologies for implementing the "No LLM Code in Dependencies" pattern effectively, including advanced dependency injection, prompt management, and error handling.

Technique 1: Factory Pattern for Dynamic Adapter Selection

Hardcoding the adapter in main.py limits flexibility. Use a Factory pattern to select the adapter based on configuration or environment.

# src/adapters/factory.py
from src.adapters.base import ChatAdapter
from src.adapters.openai_adapter import OpenAIAdapter
from src.adapters.anthropic_adapter import AnthropicAdapter # Hypothetical
from src.config.settings import settings

class AdapterFactory:
    @staticmethod
    def get_adapter() -> ChatAdapter:
        model_provider = settings.model_name.split("-")[0] # e.g., "gpt"
        if "gpt" in model_provider.lower():
            return OpenAIAdapter()
        elif "claude" in model_provider.lower():
            return AnthropicAdapter()
        else:
            raise ValueError(f"Unsupported provider: {model_provider}")

Usage in main.py:

chat_service = ChatService(adapter=AdapterFactory.get_adapter())

This allows you to switch providers by changing the config, not the code.

Technique 2: Centralized Prompt Management

Prompts are code-like artifacts. Manage them externally to avoid hardcoding strings in your adapter.

1. Store Prompts in Files: Create a prompts/ directory.
   • prompts/greeting.txt: "You are a helpful assistant. Greet the user."
   • prompts/summarize.txt: "Summarize the following text in 3 bullet points."
2. Load Dynamically:

# src/adapters/prompt_loader.py
import os

def load_prompt(prompt_name: str) -> str:
    path = os.path.join("prompts", f"{prompt_name}.txt")
    if not os.path.exists(path):
        raise FileNotFoundError(f"Prompt {prompt_name} not found")
    with open(path, "r") as f:
        return f.read().strip()

3. Use in Adapter:

# In OpenAIAdapter
def generate_response(self, messages: List[Dict[str, str]], prompt_template: str = None):
    if prompt_template:
        system_prompt = load_prompt(prompt_template)
        messages.insert(0, {"role": "system", "content": system_prompt})
    # ... rest of implementation

This separates prompt engineering from code deployment.

Technique 3: Robust Error Handling and Retry Logic

LLM APIs are unreliable. Implement exponential backoff and circuit breakers.

# src/utils/retry.py
import time
import random
from functools import wraps

def retry(max_retries=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if i == max_retries - 1:
                        raise e
                    wait_time = delay * (2 ** i) + random.uniform(0, 1)
                    time.sleep(wait_time)
        return wrapper
    return decorator

Apply this to adapter methods:

@retry(max_retries=3, delay=1)
def generate_response(self, messages: List[Dict[str, str]]) -> str:
    # API call...

Technique 4: Interface Segregation for Lightweight Dependencies

Not all business logic needs full chat capabilities. Create specialized interfaces.

# src/adapters/interfaces.py
from abc import ABC, abstractmethod
from typing import List, Dict, Any

class ITextGenerator(ABC):
    @abstractmethod
    def generate_text(self, prompt: str) -> str:
        pass

class IEmbeddingProvider(ABC):
    @abstractmethod
    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
        pass

class IToneAnalyzer(ABC):
    @abstractmethod
    def analyze_tone(self, text: str) -> Dict[str, float]:
        pass

Implement only what’s needed. This keeps dependencies minimal and improves testability.

Technique 5: Mocking for Unit Testing

Since business logic depends on interfaces, mocking is straightforward.

# tests/test_chat_service.py
import unittest
from unittest.mock import MagicMock
from src.core.chat_service import ChatService

class TestChatService(unittest.TestCase):
    def test_process_user_query(self):
        # Create a mock adapter
        mock_adapter = MagicMock()
        mock_adapter.generate_response.return_value = "Mocked Response"
        
        # Inject mock
        service = ChatService(adapter=mock_adapter)
        
        # Call method
        result = service.process_user_query("Hello")
        
        # Assert
        self.assertEqual(result, "Mocked Response")
        mock_adapter.generate_response.assert_called_once()

This allows testing business logic without calling actual LLM APIs, speeding up CI/CD pipelines.

Best Practices Summary

• Keep Adapters Thin: Adapters should only handle protocol translation (JSON to API calls).
• Centralize Configuration: All model parameters should come from settings.
• Log Interactions: Log prompts and responses (anonymized) for debugging and auditing.
• Version Interfaces: Ensure backward compatibility when updating adapter interfaces.

These techniques form the backbone of a robust, decoupled AI architecture.

---

Chapter 4: Advanced Strategies

For production-scale applications, basic decoupling is insufficient. This chapter covers optimization, scaling, edge cases, and integration with broader systems.

Optimization: Caching Responses

LLM calls are expensive and slow. Implement caching to reduce latency and cost.

# src/utils/cache.py
import redis
import json

class LLMCache:
    def __init__(self):
        self.redis_client = redis.Redis(host='localhost', port=6379, db=0)

    def get(self, key: str) -> str:
        cached = self.redis_client.get(key)
        return cached.decode('utf-8') if cached else None

    def set(self, key: str, value: str, ttl=3600):
        self.redis_client.setex(key, ttl, value)

Integrate into Adapter:

def generate_response(self, messages: List[Dict[str, str]]) -> str:
    cache_key = hashlib.md5(json.dumps(messages).encode()).hexdigest()
    cached = self.cache.get(cache_key)
    if cached:
        return cached
    
    response = self._call_llm(messages)
    self.cache.set(cache_key, response)
    return response

Scaling: Async Processing

For high-throughput applications, use asynchronous calls.

# src/adapters/async_openai_adapter.py
import asyncio
import aiohttp

class AsyncOpenAIAdapter(ChatAdapter):
    async def generate_response(self, messages: List[Dict[str, str]]) -> str:
        async with aiohttp.ClientSession() as session:
            async with session.post("https://api.openai.com/v1/chat/completions", 
                                    json={"model": "gpt-4", "messages": messages},
                                    headers={"Authorization": f"Bearer {settings.openai_api_key}"}) as resp:
                data = await resp.json()
                return data['choices'][0]['message']['content']

Use asyncio.gather to process multiple requests concurrently.

Edge Cases: Handling Context Window Limits

LLMs have limited context windows. Implement truncation or summarization strategies.

def truncate_messages(self, messages: List[Dict[str, str]], max_tokens: int) -> List[Dict[str, str]]:
    total_tokens = 0
    truncated = []
    # Simple strategy: keep recent messages
    for msg in reversed(messages):
        tokens = len(msg['content'].split()) * 1.3 # Approximation
        if total_tokens + tokens > max_tokens:
            break
        truncated.append(msg)
        total_tokens += tokens
    return list(reversed(truncated))

Integration: Service Mesh and API Gateway

Deploy your adapters as standalone microservices behind an API Gateway. The gateway handles authentication, rate limiting, and routing. This further decouples the AI layer from the application layer.

• Rate Limiting: Prevent abuse by limiting requests per user.
• Authentication: Validate API keys at the gateway level.
• Monitoring: Collect metrics on latency, error rates, and token usage.

Security: Sanitizing Inputs

Always sanitize inputs to prevent prompt injection.

def sanitize_input(self, text: str) -> str:
    # Remove special characters, escape quotes
    return text.replace('"', '\\"').replace("\n", "\\n")

Combine this with system prompts that instruct the model to ignore malicious instructions.

Advanced Dependency Injection: Using DI Containers

For larger applications, use a DI container like dependency-injector (Python) or Spring (Java).

from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    
    adapter = providers.Singleton(
        OpenAIAdapter,
        api_key=config.openai.api_key
    )
    
    chat_service = providers.Factory(
        ChatService,
        adapter=adapter
    )

container = Container()
container.config.openai.api_key.from_env("OPENAI_API_KEY")

# Use
service = container.chat_service()

This automates wiring and makes testing easier.

These strategies ensure your decoupled architecture is performant, scalable, and secure.

---

Chapter 5: Real-World Case Studies

Abstract concepts become clear when applied to real scenarios. This chapter presents three detailed case studies demonstrating the impact of "No LLM Code in Dependencies."

Case Study 1: E-Commerce Personalization Engine

Context: A mid-sized online retailer wanted to add personalized product recommendations using AI.
Initial Approach: Developers embedded a recommendation model directly into the Django web server.
Problems:

• Server memory usage spiked by 40%.
• Deployment time increased by 15 minutes due to model loading.
• Switching models required a full redeployment.

Solution:
Implemented a decoupled architecture:

1. Created a RecommendationAdapter interface.
2. Built a separate microservice running the model inference.
3. Web server sent user IDs to the microservice via gRPC.
4. Used Redis to cache recommendations.

Results:

• Server memory usage dropped by 30%.
• Deployment time reduced to 2 minutes.
• Model updates deployed independently every hour.
• Metric: 20% increase in click-through rate due to faster response times.

Case Study 2: Legal Document Review Tool

Context: A law firm built a tool to summarize legal contracts using LLMs.
Initial Approach: Hardcoded API calls in a Node.js backend with inline prompts.
Problems:

• Prompt changes required code commits.
• No audit trail for which prompt version was used.
• Security concerns about sending sensitive data to third-party APIs.

Solution:

1. Stored prompts in a version-controlled database.
2. Implemented a local LLM (Ollama) for privacy, accessed via a local adapter.
3. Used a DI container to swap between local and cloud adapters based on document sensitivity.
4. Added logging to record prompt versions and responses.

Results:

• Compliance audit passed with zero findings.
• Prompt iteration speed improved by 5x.
• Metric: Reduced legal review time by 40%.

Case Study 3: Mobile News Aggregator App

Context: A mobile app summarized news articles using AI.
Initial Approach: Bundled a small language model in the iOS/Android app.
Problems:

• App size increased by 500MB.
• Battery drain was severe.
• Model updates required app store resubmission.

Solution:

1. Removed all model code from the app.
2. Implemented a remote API call to a cloud LLM service.
3. Used JSON-RPC for efficient communication.
4. Added offline fallback with cached summaries.

Results:

• App size decreased by 200MB.
• Battery usage reduced by 15%.
• Summaries updated in real-time without app updates.
• Metric: 10% increase in user retention due to faster load times.

Lessons Learned

• Decoupling Enables Agility: Teams can update AI features independently.
• Performance Improves: Offloading heavy computation reduces resource contention.
• Security Enhances: Centralized control over data flow simplifies compliance.
• Cost Savings: Caching and efficient scaling reduce API costs.

These case studies illustrate the tangible benefits of adopting a decoupled architecture.

---

Chapter 6: Common Mistakes & Troubleshooting

Even with a solid plan, pitfalls exist. This chapter outlines common mistakes, debugging steps, and FAQs.

Common Mistakes

1. Mistake: Embedding Heavy Libraries in Core

   • Problem: Importing tensorflow or pytorch in the main application module.
   • Fix: Move these imports to adapter modules only. Use optional dependencies.

2. Mistake: Ignoring Error Propagation

   • Problem: Swallowing API errors and returning empty strings.
   • Fix: Raise specific exceptions (LLMApiError) and handle them in the service layer.

3. Mistake: Hardcoding Prompts in Adapters

   • Problem: Modifying prompts requires code changes.
   • Fix: Externalize prompts to files or databases.

4. Mistake: No Rate Limiting

   • Problem: User floods the API, causing bans.
   • Fix: Implement client-side and server-side rate limiting.

5. Mistake: Mixing Business Logic and AI Logic

   • Problem: Validating user input inside the adapter.
   • Fix: Keep validation in the service layer; adapters should only format requests.

Debugging Walkthrough

Issue: Adapter returns null.

1. Check logs for API errors.
2. Verify environment variables are loaded.
3. Test adapter independently with a simple script.
4. Check network connectivity.
5. Inspect request payload for formatting errors.

FAQ

Q1: Can I still use local models?
Yes, implement a LocalLLMAdapter that loads models from disk. The interface remains the same.

Q2: How do I handle model versioning?
Include model version in the configuration. Use a registry to map versions to endpoints.

Q3: Is this approach slower?
Initially, yes, due to network latency. However, caching and async calls mitigate this. The trade-off for maintainability is worth it.

Q4: What if the API goes down?
Implement a fallback adapter (e.g., rule-based system) and use circuit breakers.

Q5: How do I monitor usage?
Add telemetry to the adapter to log token counts, latency, and costs. Send to a dashboard like Datadog.

Addressing these mistakes proactively ensures a smoother development journey.

---

Chapter 7: Tools & Resources

Leverage the right tools to implement and maintain your decoupled architecture.

Recommended Tools

1. Pydantic Settings: Robust configuration management.
2. Redis: Caching and session storage.
3. FastAPI: High-performance async web framework for adapters.
4. LangChain/LlamaIndex: Frameworks for building LLM apps (use carefully to avoid re-introducing coupling).
5. Docker: Containerize adapters for consistent deployment.
6. Kubernetes: Orchestrate microservices.
7. Datadog/Prometheus: Monitoring and alerting.
8. Postman: API testing.
9. Git: Version control for prompts and configs.
10. HashiCorp Vault: Secure secret management.

Comparison Table

Tool	Use Case	Pros	Cons
Pydantic	Config	Type safety, easy validation	Steep learning curve
Redis	Caching	Fast, scalable	Requires separate infrastructure
FastAPI	API Layer	Async, auto-docs	Python-only
Docker	Deployment	Consistency, isolation	Overhead for small apps
LangChain	Abstraction	Rich ecosystem	Can introduce coupling if misused

Further Reading

• Documentation: OpenAI API Docs, Anthropic API Docs.
• Communities: r/MachineLearning, Stack Overflow AI tag.
• Books: "Designing Data-Intensive Applications" by Martin Kleppmann.

Using these tools effectively supports a robust, decoupled architecture.

---

Chapter 8: 30-Day Action Plan

Transform your understanding into practice with this structured plan.

Week 1: Foundation

• Day 1: Set up a new project with the structure from Chapter 2.
• Day 2: Implement the ChatAdapter interface.
• Day 3: Create OpenAIAdapter and test it.
• Day 4: Refactor existing code to remove hardcoded LLM calls.
• Day 5: Add configuration management with Pydantic.
• Day 6: Write unit tests for the interface.
• Day 7: Review and commit changes.

Week 2: Practice

• Day 8: Implement the Factory pattern.
• Day 9: Externalize prompts to files.
• Day 10: Add retry logic.
• Day 11: Integrate Redis caching.
• Day 12: Write integration tests with mocks.
• Day 13: Benchmark performance.
• Day 14: Refine error handling.

Week 3: Advanced Application

• Day 15: Containerize adapters with Docker.
• Day 16: Deploy a local adapter using Ollama.
• Day 17: Implement async calls.
• Day 18: Add monitoring/logging.
• Day 19: Create a fallback mechanism.
• Day 20: Test failure scenarios.
• Day 21: Optimize resource usage.

Week 4: Mastery

• Day 22: Document the architecture.
• Day 23: Conduct a code review.
• Day 24: Update CI/CD pipelines.
• Day 25: Train team members.
• Day 26: Plan migration for legacy code.
• Day 27: Gather feedback.
• Day 28: Finalize documentation.
• Day 29: Prepare presentation.
• Day 30: Celebrate!

Follow this plan to systematically master the "No LLM Code in Dependencies" pattern.

---

Conclusion

Adopting the "No LLM Code in Dependencies" philosophy is not just a technical upgrade; it is a strategic imperative for modern software engineering. By decoupling business logic from AI implementation, you gain agility, security, and scalability. This guide has provided the frameworks, techniques, and strategies to achieve this transformation.

Key Takeaways

• Separation of Concerns: Keep business logic clean and AI logic isolated.
• Interfaces Over Implementations: Depend on abstractions, not concrete classes.
• Configuration Driven: Make AI behavior configurable, not codified.
• Robust Error Handling: Expect failures and plan for them.

Next Steps

1. Audit your current codebase for hardcoded LLM dependencies.
2. Implement the Adapter pattern in a non-critical module.
3. Gradually migrate other components.