dbagent-cli 0.6.1__tar.gz → 0.7.1__tar.gz

{dbagent_cli-0.6.1 → dbagent_cli-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbagent-cli
-Version: 0.6.1
+Version: 0.7.1
 Summary: Enterprise AI Database Copilot, Schema Graph Introspector & Autonomous Recovery Agent (CLI)
 Author: Santhosh Gupta
 Requires-Python: >=3.9

{dbagent_cli-0.6.1 → dbagent_cli-0.7.1}/dbagent/__init__.py

@@ -2,5 +2,5 @@
 DB-Agent: Universal Database Introspection and Script Generation AI Agent (CLI).
 """
 
-__version__ = "0.6.1"
+__version__ = "0.7.1"
 __author__ = "Santhosh Gupta"

{dbagent_cli-0.6.1 → dbagent_cli-0.7.1}/dbagent/agent/pipeline.py

@@ -53,6 +53,7 @@ class PipelineResult:
     expires_at: Optional[str] = None
     # Conversational chat response
     is_chat: bool = False
+    is_direct_sql: bool = False
     message: str = ""
     # Query classification
     query_type: str = "unknown"  # read, write, ddl, chat, unknown
@@ -199,6 +200,127 @@ class QueryPipeline:
                 result.execution_time_ms = (time.time() - t_start) * 1000
                 return result
 
+        # --- 1.5. Direct Raw SQL Fast-Path (0ms AI latency, 0 tokens) ---
+        if SQLValidator.is_direct_sql(user_prompt):
+            raw_sql = user_prompt.strip().rstrip(";") + ";"
+            result.sql = raw_sql
+            result.is_direct_sql = True
+            result.query_type = SQLValidator.classify_query(raw_sql)
+            result.intent = result.query_type
+
+            # AST & Security Mode Validation
+            is_allowed, violations = SQLValidator.validate_for_mode(raw_sql, mode=self.mode)
+            result.safety_violations = violations
+            if not is_allowed:
+                result.error = f"Security Policy Violation in {self.mode.value} mode: " + "; ".join(violations)
+                result.execution_time_ms = (time.time() - t_start) * 1000
+                return result
+
+            # Check Result Cache
+            if self.use_cache and not bypass_cache and result.query_type == "read":
+                cached = self.result_cache.get(self.db_name, raw_sql)
+                if cached:
+                    cols, rows, age = cached
+                    result.columns = cols
+                    result.rows = rows
+                    result.was_executed = True
+                    result.is_cached = True
+                    result.cache_age_seconds = age
+                    result.execution_time_ms = (time.time() - t_start) * 1000
+                    result.visualization = ResultVisualizer.analyze_result_shape(cols, rows)
+                    return result
+
+            # Decide Execute or Confirm
+            should_execute = False
+            if force:
+                should_execute = True
+            elif self.mode in (OperationMode.SAFE, OperationMode.READ_ONLY):
+                should_execute = (result.query_type == "read")
+                result.was_auto_executed = should_execute
+            elif self.mode == OperationMode.CONFIRM:
+                if result.query_type == "read" and not violations:
+                    should_execute = True
+                    result.was_auto_executed = True
+                else:
+                    result.needs_confirmation = True
+                    if self.confirm_callback:
+                        if self.confirm_callback(result.sql, violations):
+                            should_execute = True
+                        else:
+                            result.execution_time_ms = (time.time() - t_start) * 1000
+                            return result
+                    else:
+                        result.execution_time_ms = (time.time() - t_start) * 1000
+                        return result
+            elif self.mode == OperationMode.ADMIN:
+                should_execute = True
+
+            if should_execute:
+                # 1. Attempt direct execution without AI (Zero AI Latency)
+                cols, rows, error = self.connector.execute_query(raw_sql, limit=100)
+                if error is None:
+                    result.columns = cols
+                    result.rows = rows
+                    result.was_executed = True
+                    result.error = None
+                    if self.mask_sensitive_data and result.rows:
+                        result.rows = SensitiveDataMasker.mask_row_set(result.columns, result.rows)
+                    if result.rows:
+                        result.visualization = ResultVisualizer.analyze_result_shape(result.columns, result.rows)
+                    if self.use_cache and result.query_type == "read":
+                        self.result_cache.set(self.db_name, raw_sql, result.columns, result.rows)
+                    exec_duration = (time.time() - t_start) * 1000
+                    result.execution_time_ms = exec_duration
+                    self.audit_logger.log_execution(
+                        database=self.db_name,
+                        user=self.user_id,
+                        question=user_prompt,
+                        sql=result.sql,
+                        mode=self.mode.value,
+                        status="SUCCESS",
+                        execution_time_ms=exec_duration,
+                        rows_returned=len(result.rows),
+                        risk_level="LOW",
+                    )
+                    self.conversation.add_turn(user_prompt=user_prompt, sql=result.sql, is_chat=False)
+                    return result
+
+                # 2. Direct query failed with DB error -> Fallback to AI Auto-Repair
+                try:
+                    exact, fuzzy = self.connector.resolve_tables(raw_sql)
+                except Exception:
+                    exact, fuzzy = [], []
+                sub_schema, join_steps = self._get_fast_schema_context(raw_sql, exact, fuzzy)
+                result.schema = sub_schema
+                result.join_steps = join_steps
+                repair_prompt = f"The following direct SQL query failed with a database error. Please correct the query using the database schema:\nFailed SQL: {raw_sql}\nError: {error}"
+                self._execute_with_retry(result, repair_prompt, sub_schema)
+
+                if result.success:
+                    if self.mask_sensitive_data and result.rows:
+                        result.rows = SensitiveDataMasker.mask_row_set(result.columns, result.rows)
+                    if result.rows:
+                        result.visualization = ResultVisualizer.analyze_result_shape(result.columns, result.rows)
+                    if self.use_cache and result.query_type == "read":
+                        self.result_cache.set(self.db_name, result.sql, result.columns, result.rows)
+                    self.conversation.add_turn(user_prompt=user_prompt, sql=result.sql, is_chat=False)
+
+                exec_duration = (time.time() - t_start) * 1000
+                result.execution_time_ms = exec_duration
+                self.audit_logger.log_execution(
+                    database=self.db_name,
+                    user=self.user_id,
+                    question=user_prompt,
+                    sql=result.sql,
+                    mode=self.mode.value,
+                    status="SUCCESS" if result.success else "FAILED",
+                    execution_time_ms=exec_duration,
+                    rows_returned=len(result.rows),
+                    risk_level=result.complexity.risk_level if result.complexity else "LOW",
+                    error=result.error,
+                )
+                return result
+
         # --- 2. Resolve Tables & Detect Ambiguity ---
         try:
             exact, fuzzy = self.connector.resolve_tables(user_prompt)

{dbagent_cli-0.6.1 → dbagent_cli-0.7.1}/dbagent/cli.py

@@ -687,16 +687,18 @@ def chat_command(
                     if not cmd_arg:
                         curr_model = model or getattr(llm, "default_model", "default")
                         console.print(f"\n[bold cyan]Active AI Provider:[/bold cyan] [bold white]{llm.name}[/bold white] | Model: [bold green]{curr_model}[/bold green]")
-                        console.print("[dim]Usage: [bold]:provider <ollama|gemini|groq|openrouter>[/bold][/dim]\n")
+                        console.print("[dim]Supported: [bold]claude, openai, deepseek, mistral, gemini, groq, openrouter, ollama[/bold][/dim]\n")
                         continue
-                    prov_target = cmd_arg.lower()
-                    if prov_target in ["ollama", "gemini", "groq", "openrouter", "mock"]:
+                    prov_target = cmd_arg.lower().strip()
+                    if prov_target in ["claude", "anthropic", "openai", "chatgpt", "gpt", "deepseek", "mistral", "gemini", "groq", "openrouter", "ollama", "local", "mock"]:
                         llm = get_llm_provider(provider_name=prov_target, config_mgr=config_mgr)
                         model = None
                         pipeline.generator.llm = llm  # Update reused pipeline
                         print_success(f"Switched AI provider to [bold cyan]{llm.name}[/bold cyan]")
+                        if not llm.is_available() and llm.name not in ["ollama", "mock"]:
+                            print_warning(f"Note: API key for {llm.name} is not set. Run `db-agent config` or set {llm.name.upper()}_API_KEY.")
                     else:
-                        print_error(f"Unknown provider '{cmd_arg}'. Supported: ollama, gemini, groq, openrouter")
+                        print_error(f"Unknown provider '{cmd_arg}'. Supported: claude, openai, deepseek, mistral, gemini, groq, openrouter, ollama")
                     continue
 
                 if cmd_name in [":model", ":models", ":providers", ":ai"]:
@@ -710,18 +712,41 @@ def chat_command(
                         if avail_models:
                             console.print(f"[bold]Available Models for {llm.name}:[/bold]")
                             model_descriptions = {
-                                "gemini-flash-lite-latest": "⚡ Ultra-Fast (~0.8s) • Recommended for instant chat & queries",
+                                # Gemini
+                                "gemini-flash-lite-latest": "⚡ Ultra-Fast (~0.8s) • Instant chat & queries",
                                 "gemini-3.6-flash": "⚡ High Quality (~3.5s) • Strong SQL reasoning & accuracy",
                                 "gemini-3.7-flash": "🧠 Deep Reasoning (~13s) • Latest flagship model",
                                 "gemini-3.1-flash-lite": "⚡ Fast Lite (~4.0s) • Low latency",
                                 "gemini-flash-latest": "⚡ Standard Flash (~7.0s)",
+                                # Claude
+                                "claude-3-7-sonnet-20250219": "🧠 Hybrid Reasoning Flagship • Deepest architecture understanding",
+                                "claude-3-5-sonnet-20241022": "⚡ High Intelligence • Expert SQL engineer & schema specialist",
+                                "claude-3-5-haiku-20241022": "⚡ Ultra-Fast (~1s) • High speed and cost efficient",
+                                "claude-3-opus-20240229": "Deep complex schema reasoning",
+                                # OpenAI
+                                "gpt-4o": "⚡ Omni Flagship • High speed multimodal & complex SQL reasoning",
+                                "gpt-4o-mini": "⚡ Ultra-Fast (~1s) • High speed and cost efficient",
+                                "gpt-4.5-preview": "🧠 Next-Generation Reasoning model",
+                                "o3-mini": "🧠 Deep STEM & Advanced Coding Reasoning",
+                                "o1": "🧠 Maximum Reasoning & Math Architecture",
+                                # DeepSeek
+                                "deepseek-chat": "⚡ DeepSeek-V3 Ultra-Fast • Strong code & SQL",
+                                "deepseek-reasoner": "🧠 DeepSeek-R1 Full Chain-of-Thought Reasoning",
+                                # Mistral
+                                "codestral-latest": "⚡ Specialized Code & SQL Architect (22B)",
+                                "mistral-large-latest": "🧠 Flagship Reasoning & Multi-language",
+                                "mistral-small-latest": "⚡ Fast & lightweight",
+                                # Groq
+                                "llama-3.3-70b-versatile": "⚡ Llama 3.3 70B (500+ tokens/sec on Groq LPUs)",
+                                "llama-3.1-8b-instant": "⚡ Ultra-Fast Llama 3.1 8B (800+ tokens/sec)",
+                                "qwen-2.5-coder-32b": "⚡ Qwen 2.5 Coder 32B specialized SQL engineer",
                             }
                             for idx, m_name in enumerate(avail_models, 1):
                                 is_active = " [bold green]✓ Active[/bold green]" if m_name == curr_model else ""
                                 desc = model_descriptions.get(m_name, "")
                                 desc_str = f" - [dim]{desc}[/dim]" if desc else ""
                                 console.print(f"  [bold cyan]{idx}[/bold cyan]. [bold white]{m_name}[/bold white]{desc_str}{is_active}")
-                            console.print("\n[dim]Quick Switch: [bold]:model 1[/bold] (ultra-fast) | [bold]:model 3.7[/bold] | [bold]:model 3.6[/bold] | [bold]:model <name>[/bold][/dim]\n")
+                            console.print("\n[dim]Quick Switch: [bold]:model <number|name>[/bold] (e.g. [bold]:model 1[/bold] or [bold]:model 3.7[/bold] or [bold]:model 4o[/bold] or [bold]:model r1[/bold])[/dim]\n")
                         continue
 
                     # Handle numeric shortcut or name shortcut
@@ -731,13 +756,23 @@ def chat_command(
                         if 0 <= choice_idx < len(avail_models):
                             target_model = avail_models[choice_idx]
                     elif target_model in ["3.7", "37"]:
-                        target_model = "gemini-3.7-flash"
+                        target_model = "claude-3-7-sonnet-20250219" if llm.name == "claude" else "gemini-3.7-flash"
+                    elif target_model in ["3.5", "35"]:
+                        target_model = "claude-3-5-sonnet-20241022" if llm.name == "claude" else "gemini-3.5-flash"
                     elif target_model in ["3.6", "36"]:
                         target_model = "gemini-3.6-flash"
-                    elif target_model in ["lite", "fast", "flash-lite", "1"]:
-                        target_model = "gemini-flash-lite-latest"
-                    elif target_model in ["3.1"]:
-                        target_model = "gemini-3.1-flash-lite"
+                    elif target_model in ["4o", "gpt4o"]:
+                        target_model = "gpt-4o"
+                    elif target_model in ["mini", "4o-mini"]:
+                        target_model = "gpt-4o-mini"
+                    elif target_model in ["r1", "reasoner"]:
+                        target_model = "deepseek-reasoner"
+                    elif target_model in ["v3", "chat"]:
+                        target_model = "deepseek-chat"
+                    elif target_model in ["codestral"]:
+                        target_model = "codestral-latest"
+                    elif target_model in ["lite", "fast", "flash-lite"]:
+                        target_model = "gemini-flash-lite-latest" if llm.name == "gemini" else "claude-3-5-haiku-20241022"
                     elif avail_models:
                         matches = [m for m in avail_models if target_model.lower() in m.lower()]
                         if matches:
@@ -1586,7 +1621,7 @@ def run_command(
 
 @app.command(name="config")
 def config_command():
-    """Interactive wizard to configure AI providers and default settings."""
+    """Interactive wizard to configure AI providers and credentials."""
     print_banner()
     console.print("[bold cyan]DB-Agent Configuration Wizard[/bold cyan]\n")
 
@@ -1594,14 +1629,38 @@ def config_command():
     console.print(f"Current Default AI Provider: [bold green]{curr_provider}[/bold green]")
     provider_choice = Prompt.ask(
         "Select Default AI Provider",
-        choices=["ollama", "gemini", "groq", "openrouter", "keep"],
+        choices=["gemini", "claude", "openai", "deepseek", "mistral", "groq", "openrouter", "ollama", "keep"],
         default="keep",
     )
     if provider_choice != "keep":
         config_mgr.set_setting("default_provider", provider_choice)
         print_success(f"Default provider updated to [bold]{provider_choice}[/bold]")
 
-    if provider_choice == "gemini":
+    if provider_choice in ["claude", "anthropic"]:
+        console.print("[dim]Get your Anthropic API key at: [bold]https://console.anthropic.com[/bold][/dim]")
+        key = Prompt.ask("Enter ANTHROPIC_API_KEY", default=config_mgr.get_setting("anthropic_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("anthropic_api_key", key)
+            print_success("Anthropic Claude API key saved.")
+    elif provider_choice in ["openai", "chatgpt"]:
+        console.print("[dim]Get your OpenAI API key at: [bold]https://platform.openai.com/api-keys[/bold][/dim]")
+        key = Prompt.ask("Enter OPENAI_API_KEY", default=config_mgr.get_setting("openai_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("openai_api_key", key)
+            print_success("OpenAI API key saved.")
+    elif provider_choice == "deepseek":
+        console.print("[dim]Get your DeepSeek API key at: [bold]https://platform.deepseek.com[/bold][/dim]")
+        key = Prompt.ask("Enter DEEPSEEK_API_KEY", default=config_mgr.get_setting("deepseek_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("deepseek_api_key", key)
+            print_success("DeepSeek API key saved.")
+    elif provider_choice == "mistral":
+        console.print("[dim]Get your Mistral API key at: [bold]https://console.mistral.ai[/bold][/dim]")
+        key = Prompt.ask("Enter MISTRAL_API_KEY", default=config_mgr.get_setting("mistral_api_key", "")).strip()
+        if key:
+            config_mgr.set_setting("mistral_api_key", key)
+            print_success("Mistral API key saved.")
+    elif provider_choice == "gemini":
         console.print("[dim]Get your free Gemini API key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
         key = Prompt.ask("Enter GEMINI_API_KEY", default=config_mgr.get_setting("gemini_api_key", "")).strip()
         if key:
@@ -1652,33 +1711,29 @@ def profiles_command():
 
 @app.command(name="models")
 def models_command():
-    """List available models across local Ollama and free cloud providers."""
+    """List available models across local Ollama and all major cloud providers."""
     print_banner()
-    console.print("[bold cyan]Supported Free & Standalone LLMs:[/bold cyan]\n")
-
-    ollama = get_llm_provider("ollama")
-    ollama_status = "[green]ONLINE (Ready)[/green]" if ollama.is_available() else "[red]OFFLINE (Run 'ollama serve')[/red]"
-    console.print(f"1. [bold white]Ollama (100% Local, Offline & Zero-Cost)[/bold white] - Status: {ollama_status}")
-    if ollama.is_available():
-        models = ollama.list_models()
-        console.print(f"   Installed Local Models: {', '.join(models) if models else 'None'}")
-    else:
-        console.print("   Recommended models: `ollama run qwen2.5-coder` or `ollama run llama3.2`")
-
-    gemini = get_llm_provider("gemini")
-    gemini_status = "[green]Configured[/green]" if gemini.is_available() else "[yellow]Not Configured (Free Key: aistudio.google.com)[/yellow]"
-    console.print(f"\n2. [bold white]Google Gemini (Free Tier)[/bold white] - Status: {gemini_status}")
-    console.print("   Available Models: `gemini-3.6-flash`, `gemini-2.5-flash`, `gemini-2.5-pro`")
-
-    groq = get_llm_provider("groq")
-    groq_status = "[green]Configured[/green]" if groq.is_available() else "[yellow]Not Configured (Free Key: console.groq.com)[/yellow]"
-    console.print(f"\n3. [bold white]Groq (Free Ultra-Fast Tier)[/bold white] - Status: {groq_status}")
-    console.print("   Available Models: `llama-3.3-70b-versatile`, `qwen-2.5-32b`")
+    console.print("[bold cyan]Supported AI Providers & Available Models:[/bold cyan]\n")
+
+    providers_to_show = [
+        ("gemini", "Google Gemini", "https://aistudio.google.com/apikey"),
+        ("claude", "Anthropic Claude", "https://console.anthropic.com"),
+        ("openai", "OpenAI / ChatGPT", "https://platform.openai.com"),
+        ("deepseek", "DeepSeek AI", "https://platform.deepseek.com"),
+        ("mistral", "Mistral AI", "https://console.mistral.ai"),
+        ("groq", "Groq (Ultra-Fast LPUs)", "https://console.groq.com"),
+        ("openrouter", "OpenRouter (100+ Models)", "https://openrouter.ai"),
+        ("ollama", "Ollama (100% Offline / Local)", "http://localhost:11434"),
+    ]
 
-    openrouter = get_llm_provider("openrouter")
-    openrouter_status = "[green]Configured[/green]" if openrouter.is_available() else "[yellow]Not Configured (openrouter.ai)[/yellow]"
-    console.print(f"\n4. [bold white]OpenRouter (Free Community Models)[/bold white] - Status: {openrouter_status}")
-    console.print("   Available Models: `meta-llama/llama-3.3-70b-instruct:free`, `qwen/qwen-2.5-coder-32b-instruct:free`\n")
+    for idx, (p_slug, p_label, p_url) in enumerate(providers_to_show, 1):
+        prov = get_llm_provider(p_slug, config_mgr=config_mgr)
+        status = "[bold green]✓ Configured & Ready[/bold green]" if prov.is_available() else f"[yellow]Not Configured ({p_url})[/yellow]"
+        console.print(f"{idx}. [bold white]{p_label}[/bold white] - Status: {status}")
+        models = prov.list_models() if hasattr(prov, "list_models") else []
+        if models:
+            console.print(f"   Models: [cyan]{', '.join(models[:5])}[/cyan]")
+        console.print("")
 
 
 # ---- setup ----
@@ -1699,7 +1754,7 @@ def setup_command(
     else:
         console.print("[bold white]Choose how you would like to setup DB-Agent:[/bold white]")
         console.print("  [bold green]1. Local Offline AI[/bold green] (Ollama + Coding Model) - [italic]100% Free, Private, Zero API Keys[/italic]")
-        console.print("  [bold cyan]2. Free Cloud AI[/bold cyan] (Google Gemini / Groq / OpenRouter) - [italic]Fast, requires free API key[/italic]")
+        console.print("  [bold cyan]2. Cloud AI[/bold cyan] (Claude / OpenAI / DeepSeek / Mistral / Gemini / Groq) - [italic]High speed & accuracy[/italic]")
         console.print("  [bold yellow]3. Normal Database CLI[/bold yellow] - [italic]No AI, use standard connect, scan & SQL tools only[/italic]\n")
 
         choice = Prompt.ask(
@@ -1720,17 +1775,41 @@ def setup_command(
             print_warning("Local setup incomplete. You can still use cloud AI or standard DB tools.")
             chosen_provider = "cloud"
     elif choice == "2":
-        console.print("\n[bold cyan]Setting up Free Cloud AI Provider...[/bold cyan]")
-        prov = Prompt.ask("Choose provider", choices=["gemini", "groq", "openrouter"], default="gemini")
+        console.print("\n[bold cyan]Setting up Cloud AI Provider...[/bold cyan]")
+        prov = Prompt.ask("Choose provider", choices=["gemini", "claude", "openai", "deepseek", "mistral", "groq", "openrouter"], default="gemini")
         config_mgr.set_setting("default_provider", prov)
-        if prov == "gemini":
-            console.print("[dim]Get free key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
+        if prov in ["claude", "anthropic"]:
+            console.print("[dim]Get Anthropic key at: [bold]https://console.anthropic.com[/bold][/dim]")
+            k = Prompt.ask("Enter ANTHROPIC_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("anthropic_api_key", k)
+                print_success("Anthropic Claude API key saved.")
+        elif prov in ["openai", "chatgpt"]:
+            console.print("[dim]Get OpenAI key at: [bold]https://platform.openai.com/api-keys[/bold][/dim]")
+            k = Prompt.ask("Enter OPENAI_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("openai_api_key", k)
+                print_success("OpenAI API key saved.")
+        elif prov == "deepseek":
+            console.print("[dim]Get DeepSeek key at: [bold]https://platform.deepseek.com[/bold][/dim]")
+            k = Prompt.ask("Enter DEEPSEEK_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("deepseek_api_key", k)
+                print_success("DeepSeek API key saved.")
+        elif prov == "mistral":
+            console.print("[dim]Get Mistral key at: [bold]https://console.mistral.ai[/bold][/dim]")
+            k = Prompt.ask("Enter MISTRAL_API_KEY", default="")
+            if k:
+                config_mgr.set_setting("mistral_api_key", k)
+                print_success("Mistral API key saved.")
+        elif prov == "gemini":
+            console.print("[dim]Get free Gemini key at: [bold]https://aistudio.google.com/apikey[/bold][/dim]")
             k = Prompt.ask("Enter GEMINI_API_KEY", default="")
             if k:
                 config_mgr.set_setting("gemini_api_key", k)
                 print_success("Gemini API key saved.")
         elif prov == "groq":
-            console.print("[dim]Get free key at: [bold]https://console.groq.com[/bold][/dim]")
+            console.print("[dim]Get free Groq key at: [bold]https://console.groq.com[/bold][/dim]")
             k = Prompt.ask("Enter GROQ_API_KEY", default="")
             if k:
                 config_mgr.set_setting("groq_api_key", k)

dbagent_cli-0.7.1/dbagent/llm/anthropic_provider.py

@@ -0,0 +1,126 @@
+"""
+Anthropic Claude LLM Provider.
+Supports claude-3-7-sonnet-20250219, claude-3-5-sonnet-20241022, claude-3-5-haiku-20241022, claude-3-opus-20240229.
+"""
+
+import json
+import os
+import requests
+from typing import Optional, Callable, List
+from dbagent.llm.base import BaseLLMProvider
+
+
+class ClaudeProvider(BaseLLMProvider):
+    """Anthropic Claude provider using direct HTTP REST API."""
+
+    FALLBACK_MODELS = [
+        "claude-3-7-sonnet-20250219",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+    ]
+
+    def __init__(self, api_key: Optional[str] = None, default_model: str = "claude-3-7-sonnet-20250219"):
+        if api_key is not None:
+            self.api_key = api_key
+        else:
+            self.api_key = os.getenv("ANTHROPIC_API_KEY") or os.getenv("CLAUDE_API_KEY")
+        self.default_model = default_model
+        self._session = requests.Session()
+        self._session.headers.update({
+            "User-Agent": "DB-Agent/0.7.0",
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        })
+        if self.api_key:
+            self._session.headers.update({"x-api-key": self.api_key})
+
+    @property
+    def name(self) -> str:
+        return "claude"
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def list_models(self) -> List[str]:
+        return self.FALLBACK_MODELS
+
+    def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        model: Optional[str] = None,
+        stream_callback: Optional[Callable[[str], None]] = None,
+    ) -> str:
+        if not self.api_key:
+            raise ValueError(
+                "Anthropic API key is not configured. Set ANTHROPIC_API_KEY environment variable or run `db-agent config`."
+            )
+
+        requested_model = model or self.default_model
+        models_to_try = [requested_model]
+        for fb in self.FALLBACK_MODELS:
+            if fb != requested_model and fb not in models_to_try:
+                models_to_try.append(fb)
+
+        payload = {
+            "model": requested_model,
+            "max_tokens": 4096,
+            "temperature": 0.1,
+            "messages": [{"role": "user", "content": prompt}],
+        }
+        if system_prompt:
+            payload["system"] = system_prompt
+
+        endpoint = "https://api.anthropic.com/v1/messages"
+        last_error = None
+
+        for target_model in models_to_try:
+            payload["model"] = target_model
+            try:
+                if stream_callback:
+                    payload["stream"] = True
+                    response = self._session.post(endpoint, json=payload, stream=True, timeout=15)
+                    if response.status_code == 200:
+                        full_text = []
+                        for line in response.iter_lines():
+                            if line:
+                                decoded = line.decode("utf-8")
+                                if decoded.startswith("data: "):
+                                    raw_json = decoded[6:]
+                                    try:
+                                        chunk = json.loads(raw_json)
+                                        delta = chunk.get("delta", {})
+                                        text_piece = delta.get("text", "")
+                                        if text_piece:
+                                            full_text.append(text_piece)
+                                            stream_callback(text_piece)
+                                    except Exception:
+                                        pass
+                        return "".join(full_text)
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"Anthropic API error ({response.status_code}): {response.text}")
+                else:
+                    payload["stream"] = False
+                    response = self._session.post(endpoint, json=payload, timeout=20)
+                    if response.status_code == 200:
+                        data = response.json()
+                        content_blocks = data.get("content", [])
+                        text_blocks = [b.get("text", "") for b in content_blocks if b.get("type") == "text"]
+                        return "".join(text_blocks)
+                    elif response.status_code in (404, 400, 503, 429):
+                        last_error = f"Model {target_model} status {response.status_code}"
+                        continue
+                    else:
+                        raise RuntimeError(f"Anthropic API error ({response.status_code}): {response.text}")
+            except requests.exceptions.Timeout:
+                last_error = f"Model {target_model} timed out"
+                continue
+            except Exception as e:
+                last_error = str(e)
+                continue
+
+        raise RuntimeError(f"Anthropic generation error: {last_error or 'All model attempts failed'}")