structured2graph 0.1.1__py3-none-any.whl

query_generation/schema_utilities.py

@@ -0,0 +1,88 @@
+"""
+Schema transformation utilities for SQL to graph migration.
+Provides utilities for transforming SQL schema elements to graph equivalents.
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaUtilities:
+    """Utilities for schema transformation and naming conventions."""
+
+    @staticmethod
+    def table_name_to_label(table_name: str) -> str:
+        """Convert table name to Cypher node label.
+
+        Args:
+            table_name: SQL table name (e.g., 'user_profiles')
+
+        Returns:
+            Cypher label in PascalCase (e.g., 'UserProfiles')
+        """
+        return "".join(word.capitalize() for word in table_name.split("_"))
+
+    @staticmethod
+    def column_name_to_property(column_name: str) -> str:
+        """Convert column name to graph property name.
+
+        Args:
+            column_name: SQL column name
+
+        Returns:
+            Property name (currently unchanged, but extensible)
+        """
+        return column_name
+
+    @staticmethod
+    def generate_relationship_name(to_table: str, join_table: str | None = None) -> str:
+        """Generate semantic relationship name.
+
+        Args:
+            to_table: Target table name
+            join_table: Join table name for many-to-many relationships
+
+        Returns:
+            Relationship name in UPPER_CASE
+        """
+        if join_table:
+            return SchemaUtilities.table_name_to_label(join_table).upper()
+        else:
+            to_label = SchemaUtilities.table_name_to_label(to_table).upper()
+            return f"HAS_{to_label}"
+
+    @staticmethod
+    def is_metadata_column(column_name: str) -> bool:
+        """Check if a column is a metadata/system column.
+
+        Args:
+            column_name: Name of the column to check
+
+        Returns:
+            True if it's a metadata column, False otherwise
+        """
+        metadata_columns = {
+            "id",
+            "created_at",
+            "updated_at",
+            "created_on",
+            "updated_on",
+            "timestamp",
+            "version",
+            "deleted_at",
+            "modified_at",
+        }
+        return column_name.lower() in metadata_columns
+
+    @staticmethod
+    def is_foreign_key_column(column_name: str) -> bool:
+        """Check if a column name suggests it's a foreign key.
+
+        Args:
+            column_name: Name of the column to check
+
+        Returns:
+            True if it appears to be a foreign key, False otherwise
+        """
+        return column_name.lower().endswith("_id") and column_name.lower() != "id"

structured2graph-0.1.1.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: structured2graph
+Version: 0.1.1
+Summary: Database migration agent from structured data (e.g. SQL) to graph.
+Project-URL: Homepage, https://github.com/memgraph/ai-toolkit
+Project-URL: Repository, https://github.com/memgraph/ai-toolkit
+Project-URL: Issues, https://github.com/memgraph/ai-toolkit/issues
+Project-URL: Documentation, https://github.com/memgraph/ai-toolkit/tree/main/agents/sql2graph
+Author-email: Memgraph <tech@memgraph.com>
+Maintainer-email: Memgraph <tech@memgraph.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: database-migration,etl,graph-database,knowledge-graph,memgraph,sql-to-graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: langchain-anthropic>=0.3.0
+Requires-Dist: langchain-core>=1.0.0
+Requires-Dist: langchain-google-genai>=2.0.0
+Requires-Dist: langchain-openai>=0.2.0
+Requires-Dist: langchain>=1.0.0
+Requires-Dist: langgraph>=0.2.0
+Requires-Dist: memgraph-toolbox>=0.1.4
+Requires-Dist: mysql-connector-python>=9.0.0
+Requires-Dist: neo4j>=5.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: psycopg2-binary>=2.9
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pymysql>=1.1.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: sqlalchemy>=2.0.0
+Description-Content-Type: text/markdown
+
+# SQL Database to Graph Migration Agent
+
+Intelligent database migration agent that transforms SQL databases (MySQL, PostgreSQL) into graph databases, powered by LLM analysis and LangGraph workflows.
+
+## Overview
+
+This package provides a sophisticated migration agent that:
+
+- **Analyzes SQL database schemas** - Automatically discovers tables, relationships, and constraints
+- **Generates optimal graph models** - Uses AI to create node and relationship structures
+- **Creates indexes and constraints** - Ensures performance and data integrity
+- **Handles complex relationships** - Converts foreign keys to graph relationships
+- **Incremental refinement** - Review each table, adjust the model
+  immediately, then enter the interactive refinement loop once all tables
+  are processed
+- **Comprehensive validation** - Verifies migration results and data integrity
+
+## Installation
+
+```bash
+# Install the package
+uv pip install .
+
+# Or install in development mode
+uv pip install -e .
+```
+
+## Quick Start
+
+Run the migration agent:
+
+```bash
+uv run main
+```
+
+The agent will guide you through:
+
+1. Environment setup and database connections
+2. Graph modeling strategy selection
+3. Automatic or incremental migration mode
+4. Complete migration workflow with progress tracking
+
+> **Incremental review:** The LLM now drafts the entire graph model in a single
+> shot and then walks you through table-level changes detected since the last
+> migration. You only need to approve (or tweak) the differences that matter.
+
+You can also preconfigure the workflow using CLI flags or environment variables:
+
+```bash
+uv run main --mode incremental --strategy llm --meta-graph reset --log-level DEBUG
+```
+
+| Option                                 | Environment          | Description                                                   |
+| -------------------------------------- | -------------------- | ------------------------------------------------------------- |
+| `--mode {automatic,incremental}`       | `SQL2MG_MODE`        | Selects automatic or incremental modeling flow.               |
+| `--strategy {deterministic,llm}`       | `SQL2MG_STRATEGY`    | Chooses deterministic or LLM-powered HyGM strategy.           |
+| `--provider {openai,anthropic,gemini}` | `LLM_PROVIDER`       | Selects LLM provider (auto-detects if not specified).         |
+| `--model MODEL_NAME`                   | `LLM_MODEL`          | Specifies LLM model name (uses provider default if not set).  |
+| `--meta-graph {auto,skip,reset}`       | `SQL2MG_META_POLICY` | Controls how stored meta graph data is used (default `auto`). |
+| `--log-level LEVEL`                    | `SQL2MG_LOG_LEVEL`   | Sets logging verbosity (`DEBUG`, `INFO`, etc.).               |
+
+## Configuration
+
+Set up your environment variables in `.env`:
+
+```bash
+# Select source database (mysql or postgresql)
+SOURCE_DB_TYPE=postgresql
+
+# PostgreSQL Database (used when SOURCE_DB_TYPE=postgresql)
+POSTGRES_HOST=localhost
+POSTGRES_PORT=5432
+POSTGRES_DATABASE=pagila
+POSTGRES_USER=username
+POSTGRES_PASSWORD=password
+POSTGRES_SCHEMA=public
+
+# MySQL Database (used when SOURCE_DB_TYPE=mysql)
+MYSQL_HOST=localhost
+MYSQL_PORT=3306
+MYSQL_DATABASE=sakila
+MYSQL_USER=username
+MYSQL_PASSWORD=password
+
+# Memgraph Database
+MEMGRAPH_URL=bolt://localhost:7687
+MEMGRAPH_USERNAME=
+MEMGRAPH_PASSWORD=
+MEMGRAPH_DATABASE=memgraph
+
+# LLM API Keys (for LLM-powered features - choose one or more)
+OPENAI_API_KEY=your_openai_key         # For GPT models
+# ANTHROPIC_API_KEY=your_anthropic_key # For Claude models
+# GOOGLE_API_KEY=your_google_key       # For Gemini models
+
+# LLM Provider Configuration (optional - auto-detects if not set)
+# LLM_PROVIDER=openai                  # Options: openai, anthropic, gemini
+# LLM_MODEL=gpt-4o-mini                # Specific model name
+
+# Optional migration defaults (override CLI prompts)
+SQL2MG_MODE=automatic
+SQL2MG_STRATEGY=deterministic
+SQL2MG_META_POLICY=auto
+SQL2MG_LOG_LEVEL=INFO
+```
+
+When switching `SOURCE_DB_TYPE` remember to update the matching credential block and rerun `uv sync` so dependencies like `psycopg2-binary` are installed for PostgreSQL support.
+
+Make sure that Memgraph is started with the `--schema-info-enabled=true`, since agent uses the schema information from Memgraph `SHOW SCHEMA INFO`.
+
+## Multi-LLM Provider Support
+
+The agent supports multiple LLM providers for AI-powered graph modeling:
+
+### Supported Providers
+
+- **OpenAI** (GPT models) - Default: `gpt-4o-mini`
+- **Anthropic** (Claude models) - Default: `claude-3-5-sonnet-20241022`
+- **Google** (Gemini models) - Default: `gemini-1.5-pro`
+
+### Usage Examples
+
+```bash
+# Auto-detect provider based on API keys
+uv run main --strategy llm
+
+# Use specific provider
+uv run main --strategy llm --provider anthropic
+
+# Use specific model
+uv run main --strategy llm --provider openai --model gpt-4o
+
+# All options together
+uv run main --mode incremental --strategy llm --provider gemini --model gemini-1.5-flash
+```
+
+All providers support **structured outputs** for consistent graph model generation. The system automatically validates schemas using Pydantic models.
+
+📖 **[Full Multi-Provider Documentation](docs/MULTI_PROVIDER_SUPPORT.md)**
+
+# Arhitecture
+
+```
+core/hygm/
+├── hygm.py # Main orchestrator class
+├── models/ # Data models and structures
+│ ├── graph_models.py # Core graph representation
+│ ├── llm_models.py # LLM-specific models
+│ ├── operations.py # Interactive operations
+│ └── sources.py # Source tracking
+└── strategies/ # Modeling strategies
+├── base.py # Abstract interface
+├── deterministic.py # Rule-based modeling
+└── llm.py # AI-powered modeling
+```

structured2graph-0.1.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+core/__init__.py,sha256=H6KdK_X5BwtN59bPkA58KTdIS2mGTxYz_0Dzd_Bu3M4,509
+core/migration_agent.py,sha256=mN2mAllkvp9Pv04hlK21YAC0XQy73uuxV3Nq1-M6qpw,53428
+core/hygm/__init__.py,sha256=SAHaWatqR5bp5eYHJBgOGWrYtkLmXvS3T6rUMNtZv1E,1809
+core/hygm/hygm.py,sha256=4SgL1qRHg9FuGP9_pUVjUOG1iiXgA9q-_DqpUJ-8aok,93958
+core/hygm/models/__init__.py,sha256=1CE9wQt-Df_RJZb4wgZKInFdpysqbDD1OVNubaPIdWU,1848
+core/hygm/models/graph_models.py,sha256=pvBaqYxFIDZWpEu-wt7kQO8ClOUBq2d3JNwofcxGTyE,24268
+core/hygm/models/llm_models.py,sha256=pKjxanUmX2O6-JPbmTkzD5K22YlvggYF-Zcy86J0w4A,8022
+core/hygm/models/operations.py,sha256=MVgywKczqk22NC94TIbKcIJYyD4b6KdDfXOFf41KxMU,6039
+core/hygm/models/sources.py,sha256=bJx-ldfgKsg8JUSzTODkUWL4D3uJLPubGxmIaC3Xjl4,2174
+core/hygm/models/user_operations.py,sha256=13vvOq4HdwqoZEWw2FTdyzT6NMtXp8gXd4nFjLMwauk,6333
+core/hygm/strategies/__init__.py,sha256=JVerSHnI_tMPLE_IJv2QAIGrPSFKhDAjyaev5EBDITw,464
+core/hygm/strategies/base.py,sha256=WmIp0BOvJmYmh8-aSWFRS1i38JZQkcwvUK6bhtz0EEk,973
+core/hygm/strategies/deterministic.py,sha256=cxFrDqMY6ka_yRK-u4SLxFqRT_sA3TuRm1G1ty4dHnE,10035
+core/hygm/strategies/llm.py,sha256=s0_1c8IgbU7otAOSo2hLUpw3xJxeDubbEoB1gBegfc4,36439
+core/hygm/validation/__init__.py,sha256=myoFL6jqLn2qyNHb-0ME2m9TkZroMp6ERp3g11yAiNY,957
+core/hygm/validation/base.py,sha256=3IxFtgAwDu30wYvsuX2Ykvp39-KCkz3N_8DPs9u42Uw,5687
+core/hygm/validation/graph_schema_validator.py,sha256=QIWzUBuo-v2eybSVA7BWjsc3BO_-m0snSrhVmjg-hPI,28895
+core/hygm/validation/memgraph_data_validator.py,sha256=QeuCRxjB1IP5KyfkMaiX0Xy7-vi98mLWezV1EQQFOiQ,39290
+core/schema/spec.json,sha256=Om_CWtAY4yWq9M_CfpZj2T1ubr1Yt1XlpKncshc6yNw,5411
+core/utils/meta_graph.py,sha256=r4eSfqjonKtY-CIaB9h9UIVzmarWloge9EmlZrsxAYU,3683
+database/__init__.py,sha256=_39-82CK_BoqZ___NHCfNKMBol5tYvzRm9JObvzPB0g,729
+database/analyzer.py,sha256=KPIn0qW9sgQPtBEwgoL9hbJGjdA8Uz5LUMUyLQ4ezrA,12492
+database/factory.py,sha256=TCcZQFJ427qzp6XeQL-07nnWBarOUn2rMZsdPkj4FUo,7313
+database/models.py,sha256=sEFRNXdzvfRLIO4QYbkiCOF1efYmfB3hb10dfZT90eU,6289
+database/adapters/__init__.py,sha256=XBPy5A_91XfkcJMvmhl8sYPIXEQHGJQQ3x5da9t05Vw,212
+database/adapters/memgraph.py,sha256=KWEep0Q5zkGLXeKg1Q-mthPdzsWKPeN9DqOCU1bOTDc,10132
+database/adapters/mysql.py,sha256=3BNp_4ffbfIbVUIWWURbpYQzKTjLfOf-iqfZle0qt4E,10512
+database/adapters/postgresql.py,sha256=LzI_RaLiiGtSN-rLWPTBT-Okf-OvtArI758MAJunQ2E,11264
+query_generation/__init__.py,sha256=dcJD3LqI55LrtoHyfruM0D5xrGmOD7zvyfbTOMMxrs0,469
+query_generation/cypher_generator.py,sha256=vQSkv0XfMBMS7owxvoLeDVfvXoZ6MI0tbIllcGK378k,4640
+query_generation/schema_utilities.py,sha256=W_p_V5VNmVFbegNnFwrIi0G7v7WRt9xHA5P5BeXxNTQ,2550
+utils/__init__.py,sha256=6FW-aebS9wuwWR6izR8uvKFfmmK7RGA6iixnNdNdMGc,1558
+utils/config.py,sha256=pGyQ-sESg1HtpHIWEus_xYG9KEqatnWL7bZqjUEGMCI,8218
+utils/environment.py,sha256=UtM1HkQe5znFVaEzXtpNK01GHy1J0cjHzidyoG4EmgE,13798
+__init__.py,sha256=PbyEy0zP99byR1LTjH0ImWtJ0S5M2ZyTuUjp0i-KKKw,1314
+main.py,sha256=EnUw0cEAxezlo9hJUnUlm4xey0M8kdVzbmm9WJYWugg,17042
+structured2graph-0.1.1.dist-info/METADATA,sha256=Ai50jsvZ16Sl5nqg8qMPnICfxzKyzjQcKsqOvrE9_KY,7453
+structured2graph-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+structured2graph-0.1.1.dist-info/entry_points.txt,sha256=kdLlrnE_KtaBIqsKIj0oSS_qwEiO9eDYLcGD3JmOrBs,47
+structured2graph-0.1.1.dist-info/licenses/LICENSE,sha256=ZzJm0xDxij_hPJDfDVZ2SYNYaIN-e1CA3TnB94I09Rs,1070
+structured2graph-0.1.1.dist-info/RECORD,,

structured2graph-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

structured2graph-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+structured2graph = main:main

structured2graph-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Memgraph Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

utils/__init__.py

@@ -0,0 +1,57 @@
+"""
+Utilities package for the SQL to graph migration agent.
+
+This package contains reusable utility modules for environment management,
+database probing, configuration management, and other common functionality.
+"""
+
+from .environment import (
+    MigrationEnvironmentError,
+    DatabaseConnectionError,
+    load_environment,
+    get_required_environment_variables,
+    get_optional_environment_variables,
+    validate_environment_variables,
+    get_source_db_config,
+    get_memgraph_config,
+    probe_source_connection,
+    probe_memgraph_connection,
+    validate_llm_providers,
+    setup_and_validate_environment,
+    probe_all_connections,
+    print_environment_help,
+    print_troubleshooting_help,
+)
+
+from .config import (
+    MigrationConfig,
+    get_preset_config,
+    merge_config_with_preset,
+    print_config_summary,
+    get_available_presets,
+)
+
+__all__ = [
+    # Environment utilities
+    "MigrationEnvironmentError",
+    "DatabaseConnectionError",
+    "load_environment",
+    "get_required_environment_variables",
+    "get_optional_environment_variables",
+    "validate_environment_variables",
+    "get_source_db_config",
+    "get_memgraph_config",
+    "probe_source_connection",
+    "probe_memgraph_connection",
+    "validate_llm_providers",
+    "setup_and_validate_environment",
+    "probe_all_connections",
+    "print_environment_help",
+    "print_troubleshooting_help",
+    # Configuration utilities
+    "MigrationConfig",
+    "get_preset_config",
+    "merge_config_with_preset",
+    "print_config_summary",
+    "get_available_presets",
+]

utils/config.py

@@ -0,0 +1,235 @@
+"""
+Configuration management utilities for the migration agent.
+
+This module handles configuration parsing, validation, and default settings
+for different environments and use cases.
+"""
+
+import os
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+
+from .environment import get_source_db_type
+
+
+@dataclass
+class MigrationConfig:
+    """Configuration class for migration settings."""
+
+    # Source database settings
+    source_db_type: str
+    source_db_host: str
+    source_db_user: str
+    source_db_password: str
+    source_db_database: str
+    source_db_port: int
+    source_db_schema: Optional[str]
+
+    # Memgraph settings
+    memgraph_url: str
+    memgraph_username: str
+    memgraph_password: str
+    memgraph_database: str
+
+    # OpenAI settings
+    openai_api_key: str
+
+    # Migration settings
+    relationship_naming_strategy: str = "table_based"
+    interactive_table_selection: bool = True
+
+    @classmethod
+    def from_environment(cls) -> "MigrationConfig":
+        """Create configuration from environment variables."""
+        db_type = get_source_db_type()
+        if db_type == "postgresql":
+            source_host = os.getenv("POSTGRES_HOST", "localhost")
+            source_user = os.getenv("POSTGRES_USER", "postgres")
+            source_password = os.getenv("POSTGRES_PASSWORD", "")
+            source_database = os.getenv("POSTGRES_DATABASE", "postgres")
+            source_port = int(os.getenv("POSTGRES_PORT", "5432"))
+            source_schema = os.getenv("POSTGRES_SCHEMA", "public")
+        else:
+            source_host = os.getenv("MYSQL_HOST", "host.docker.internal")
+            source_user = os.getenv("MYSQL_USER", "root")
+            source_password = os.getenv("MYSQL_PASSWORD", "")
+            source_database = os.getenv("MYSQL_DATABASE", "sakila")
+            source_port = int(os.getenv("MYSQL_PORT", "3306"))
+            source_schema = None
+
+        return cls(
+            source_db_type=db_type,
+            source_db_host=source_host,
+            source_db_user=source_user,
+            source_db_password=source_password,
+            source_db_database=source_database,
+            source_db_port=source_port,
+            source_db_schema=source_schema,
+            memgraph_url=os.getenv("MEMGRAPH_URL", "bolt://localhost:7687"),
+            memgraph_username=os.getenv("MEMGRAPH_USERNAME", ""),
+            memgraph_password=os.getenv("MEMGRAPH_PASSWORD", ""),
+            memgraph_database=os.getenv("MEMGRAPH_DATABASE", "memgraph"),
+            openai_api_key=os.getenv("OPENAI_API_KEY", ""),
+            relationship_naming_strategy=os.getenv(
+                "RELATIONSHIP_NAMING_STRATEGY", "table_based"
+            ),
+            interactive_table_selection=os.getenv(
+                "INTERACTIVE_TABLE_SELECTION", "true"
+            ).lower()
+            == "true",
+        )
+
+    def to_source_db_config(self) -> Dict[str, Any]:
+        """Convert to a dictionary suitable for analyzer creation."""
+        config: Dict[str, Any] = {
+            "database_type": self.source_db_type,
+            "host": self.source_db_host,
+            "user": self.source_db_user,
+            "password": self.source_db_password,
+            "database": self.source_db_database,
+            "port": self.source_db_port,
+        }
+        if self.source_db_type == "postgresql" and self.source_db_schema:
+            config["schema"] = self.source_db_schema
+        return config
+
+    def to_memgraph_config(self) -> Dict[str, str]:
+        """Convert to Memgraph configuration dictionary."""
+        return {
+            "url": self.memgraph_url,
+            "username": self.memgraph_username,
+            "password": self.memgraph_password,
+            "database": self.memgraph_database,
+        }
+
+    def validate(self) -> tuple[bool, list[str]]:
+        """
+        Validate the configuration.
+
+        Returns:
+            Tuple of (is_valid, validation_errors)
+        """
+        errors: list[str] = []
+
+        if not self.openai_api_key:
+            errors.append("OPENAI_API_KEY is required")
+
+        if self.source_db_type == "postgresql":
+            if not 1 <= self.source_db_port <= 65535:
+                errors.append(f"Invalid PostgreSQL port: {self.source_db_port}")
+        else:
+            if not 1 <= self.source_db_port <= 65535:
+                errors.append(f"Invalid MySQL port: {self.source_db_port}")
+
+        valid_strategies = ["table_based", "llm"]
+        if self.relationship_naming_strategy not in valid_strategies:
+            errors.append(
+                "Invalid relationship_naming_strategy: "
+                f"{self.relationship_naming_strategy}. Must be one of: "
+                f"{valid_strategies}"
+            )
+
+        return len(errors) == 0, errors
+
+
+def get_preset_config(preset_name: str) -> Optional[Dict[str, Any]]:
+    """
+    Get a preset configuration for common scenarios.
+
+    Args:
+        preset_name: Name of the preset configuration
+
+    Returns:
+        Dictionary with preset configuration values or None if not found
+    """
+    presets = {
+        "local_development": {
+            "source_db_type": "mysql",
+            "source_db_host": "localhost",
+            "source_db_port": 3306,
+            "source_db_user": "root",
+            "source_db_database": "sakila",
+            "memgraph_url": "bolt://localhost:7687",
+            "relationship_naming_strategy": "table_based",
+            "interactive_table_selection": True,
+        },
+        "docker_development": {
+            "source_db_type": "mysql",
+            "source_db_host": "host.docker.internal",
+            "source_db_port": 3306,
+            "source_db_user": "root",
+            "source_db_database": "sakila",
+            "memgraph_url": "bolt://localhost:7687",
+            "relationship_naming_strategy": "table_based",
+            "interactive_table_selection": True,
+        },
+        "production": {
+            "source_db_type": "mysql",
+            "source_db_host": "mysql-server",
+            "source_db_port": 3306,
+            "source_db_user": "migration_user",
+            "memgraph_url": "bolt://memgraph-server:7687",
+            "relationship_naming_strategy": "llm",
+            "interactive_table_selection": False,
+        },
+    }
+
+    return presets.get(preset_name)
+
+
+def merge_config_with_preset(
+    config: MigrationConfig, preset_name: str
+) -> MigrationConfig:
+    """
+    Merge configuration with a preset, keeping existing values.
+
+    Args:
+        config: Existing configuration
+        preset_name: Name of the preset to merge
+
+    Returns:
+        New configuration with preset values applied where not set
+    """
+    preset = get_preset_config(preset_name)
+    if not preset:
+        return config
+
+    config_dict = config.__dict__.copy()
+
+    for key, preset_value in preset.items():
+        if key not in config_dict:
+            continue
+        current_value = config_dict[key]
+        if (
+            not current_value
+            or (key == "source_db_host" and current_value == "host.docker.internal")
+            or (key == "memgraph_url" and current_value == "bolt://localhost:7687")
+        ):
+            config_dict[key] = preset_value
+
+    return MigrationConfig(**config_dict)
+
+
+def print_config_summary(config: MigrationConfig) -> None:
+    """Print a summary of the configuration."""
+    print("🔧 Configuration Summary:")
+    print("-" * 30)
+    source_details = (
+        f"Source DB: {config.source_db_type}://"
+        f"{config.source_db_user}@{config.source_db_host}:"
+        f"{config.source_db_port}"
+    )
+    print(source_details)
+    print(f"Database: {config.source_db_database}")
+    if config.source_db_type == "postgresql" and config.source_db_schema:
+        print(f"Schema: {config.source_db_schema}")
+    print(f"Memgraph: {config.memgraph_url}")
+    print(f"Strategy: {config.relationship_naming_strategy}")
+    print(f"Interactive: {config.interactive_table_selection}")
+    print(f"OpenAI API: {'✅ Set' if config.openai_api_key else '❌ Missing'}")
+    print()
+
+
+def get_available_presets() -> list[str]:
+    """Get a list of available preset names."""
+    return ["local_development", "docker_development", "production"]