Code Migration

langchain migrate [grit-args] [options]

Options:
  --diff               Show changes without applying them (dry-run mode)
  --interactive        Prompt for confirmation before making each change
  
Additional Arguments:
  Any additional arguments are passed directly to the Grit CLI

# Run migration with preview (recommended first step)
langchain migrate --diff

# Run migration interactively
langchain migrate --interactive

# Run migration with both diff and interactive modes
langchain migrate --diff --interactive

# Run migration and apply changes
langchain migrate

# Pass additional Grit arguments
langchain migrate --disable some_pattern --interactive

langchain.llms.openai → langchain_community.llms.openai → langchain_openai.llms

def migrate(
    ctx: typer.Context,
    diff: bool = False,
    interactive: bool = False,
) -> None:
    """Migrate langchain to the most recent version."""

def get_gritdir_path() -> Path:
    """Get the path to the grit directory."""

def generate_raw_migrations(
    from_package: str, 
    to_package: str, 
    filter_by_all: bool = False
) -> list[tuple[str, str]]:
    """
    Generate raw migration patterns between packages.
    
    Args:
        from_package: Source package name
        to_package: Target package name  
        filter_by_all: Whether to filter by __all__ exports only
        
    Returns:
        List of (from_import, to_import) tuples
    """

def generate_simplified_migrations(
    from_package: str,
    to_package: str, 
    filter_by_all: bool = True
) -> list[tuple[str, str]]:
    """
    Generate simplified migration patterns with duplicate removal.
    
    Args:
        from_package: Source package name
        to_package: Target package name
        filter_by_all: Whether to filter by __all__ exports only
        
    Returns:
        List of unique (from_import, to_import) tuples
    """

def generate_top_level_imports(pkg: str) -> list[tuple[str, str]]:
    """
    Generate migration patterns for top-level package imports.
    
    Args:
        pkg: Package name to analyze
        
    Returns:
        List of (old_import, new_import) tuples for top-level imports
    """

class ImportExtractor(ast.NodeVisitor):
    """
    AST visitor for extracting import statements from Python code.
    
    Attributes:
        imports: List of discovered import statements
        from_imports: List of discovered from-import statements
    """
    
    def __init__(self) -> None:
        """Initialize the import extractor."""
        
    def visit_Import(self, node: ast.Import) -> None:
        """Visit import statements."""
        
    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
        """Visit from-import statements."""

from langchain_cli.namespaces.migrate.generate.utils import generate_raw_migrations, generate_simplified_migrations, ImportExtractor

# Generate migration patterns
raw_migrations = generate_raw_migrations("langchain.llms", "langchain_community.llms")
print(f"Raw migrations: {raw_migrations}")

simplified_migrations = generate_simplified_migrations("langchain.embeddings", "langchain_openai")
print(f"Simplified migrations: {simplified_migrations}")

# Extract imports from code
import ast
code = """
from langchain.llms import OpenAI
from langchain.embeddings import OpenAIEmbeddings
import langchain.vectorstores
"""

tree = ast.parse(code)
extractor = ImportExtractor()
extractor.visit(tree)
print(f"Found imports: {extractor.from_imports}")

# Before (LangChain 0.1)
from langchain.llms import OpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma

# After First Migration (Community)
from langchain_community.llms import OpenAI
from langchain_community.embeddings import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma

# After Second Migration (Partner packages)
from langchain_openai import OpenAI, OpenAIEmbeddings
from langchain_chroma import Chroma

# Before
llm = OpenAI(temperature=0.7)
embeddings = OpenAIEmbeddings()

# After
llm = OpenAI(temperature=0.7)  # Same usage, different import
embeddings = OpenAIEmbeddings()  # Same usage, different import

# Before (deprecated patterns)
from langchain.chains import ConversationChain
chain = ConversationChain(llm=llm, memory=memory)

# After (updated patterns)  
from langchain.chains import ConversationChain
chain = ConversationChain(llm=llm, memory=memory)  # Updated internally