Add local model inference support and improve Neo4j troubleshooting

- Add support for localhost model inference (local LLM servers)
- Extend CLI and wizard to accept local model endpoints
- Add Google/Gemini API key support for google-adk framework
- Add --demo shortcut flag for quick demo setup
- Improve README with comprehensive Neo4j authentication troubleshooting

Author: tomd

src/create_context_graph/cli.py

@@ -50,6 +50,7 @@
 @click.option("--neo4j-aura-env", type=click.Path(exists=True), help="Path to Neo4j Aura .env file with credentials")
 @click.option("--neo4j-local", is_flag=True, help="Use @johnymontana/neo4j-local for local Neo4j (no Docker)")
 @click.option("--anthropic-api-key", envvar="ANTHROPIC_API_KEY", help="Anthropic API key for LLM generation")
+@click.option("--anthropic-base-url", envvar="ANTHROPIC_BASE_URL", help="Anthropic-compatible API base URL (e.g., http://127.0.0.1:8082)")
 @click.option("--openai-api-key", envvar="OPENAI_API_KEY", help="OpenAI API key for LLM generation")
 @click.option("--google-api-key", envvar="GOOGLE_API_KEY", help="Google/Gemini API key (required for google-adk framework)")
 @click.option("--custom-domain", type=str, help="Natural language description for custom domain generation (requires --anthropic-api-key)")
@@ -73,6 +74,7 @@ def main(
     neo4j_aura_env: str | None,
     neo4j_local: bool,
     anthropic_api_key: str | None,
+    anthropic_base_url: str | None,
     openai_api_key: str | None,
     google_api_key: str | None,
     custom_domain: str | None,
@@ -124,7 +126,7 @@ def main(
         console.print("[bold]Generating custom domain ontology...[/bold]")
         try:
             custom_ontology, custom_domain_yaml = generate_custom_domain(
-                custom_domain, anthropic_api_key
+                custom_domain, anthropic_api_key, base_url=anthropic_base_url
             )
         except ValueError as e:
             console.print(f"[red]Error:[/red] {e}")
@@ -169,6 +171,7 @@ def main(
             neo4j_password=neo4j_password,
             neo4j_type=neo4j_type_resolved,
             anthropic_api_key=anthropic_api_key,
+            anthropic_base_url=anthropic_base_url,
             openai_api_key=openai_api_key,
             google_api_key=google_api_key,
             generate_data=demo_data,
@@ -185,7 +188,21 @@ def main(
         # Launch interactive wizard
         from create_context_graph.wizard import run_wizard
 
-        config = run_wizard()
+        config = run_wizard(
+            project_name=project_name,
+            domain=domain,
+            framework=framework,
+            anthropic_api_key=anthropic_api_key,
+            anthropic_base_url=anthropic_base_url,
+            openai_api_key=openai_api_key,
+            connector=connector,
+            demo_data=demo_data,
+            neo4j_uri=neo4j_uri,
+            neo4j_username=neo4j_username,
+            neo4j_password=neo4j_password,
+            neo4j_local=neo4j_local,
+            neo4j_aura_env=neo4j_aura_env,
+        )
 
     # Resolve output directory
     out = Path(output_dir) if output_dir else Path.cwd() / config.project_slug

src/create_context_graph/config.py

@@ -73,6 +73,7 @@ class ProjectConfig(BaseModel):
     neo4j_password: str = Field(default="password")
     neo4j_type: Literal["docker", "existing", "aura", "local"] = Field(default="docker")
     anthropic_api_key: str | None = Field(default=None)
+    anthropic_base_url: str | None = Field(default=None)
     openai_api_key: str | None = Field(default=None)
     google_api_key: str | None = Field(default=None)
     generate_data: bool = Field(default=False)

src/create_context_graph/custom_domain.py

@@ -211,13 +211,14 @@ def generate_custom_domain(
     api_key: str,
     provider: str = "anthropic",
     max_retries: int = 3,
+    base_url: str | None = None,
 ) -> tuple[DomainOntology, str]:
     """Generate a complete domain ontology from a natural language description.
 
     Returns (DomainOntology, raw_yaml_string) on success.
     Raises ValueError if generation fails after max_retries.
     """
-    client, resolved_provider = _get_llm_client(api_key, provider)
+    client, resolved_provider = _get_llm_client(api_key, provider, base_url)
     if client is None:
         raise ValueError(
             "Could not initialize LLM client. Install 'anthropic' or 'openai' package."

src/create_context_graph/generator.py

@@ -42,12 +42,15 @@
 # ---------------------------------------------------------------------------
 
 
-def _get_llm_client(api_key: str, provider: str = "anthropic"):
+def _get_llm_client(api_key: str, provider: str = "anthropic", base_url: str | None = None):
     """Get an LLM client for generation."""
     if provider == "anthropic":
         try:
             import anthropic
-            return anthropic.Anthropic(api_key=api_key), "anthropic"
+            client_kwargs = {"api_key": api_key}
+            if base_url:
+                client_kwargs["base_url"] = base_url
+            return anthropic.Anthropic(**client_kwargs), "anthropic"
         except ImportError:
             pass
 
@@ -70,7 +73,21 @@ def _llm_generate(client, provider: str, prompt: str, system: str = "") -> str:
             system=system,
             messages=[{"role": "user", "content": prompt}],
         )
-        return response.content[0].text
+        # Handle both text content and thinking blocks
+        content = response.content[0]
+        if hasattr(content, 'text'):
+            return content.text
+        elif hasattr(content, 'thinking'):
+            # Find the next text block after thinking
+            for block in response.content:
+                if hasattr(block, 'text'):
+                    return block.text
+        # Fallback: extract text from all blocks
+        text_parts = []
+        for block in response.content:
+            if hasattr(block, 'text'):
+                text_parts.append(block.text)
+        return ''.join(text_parts)
     elif provider == "openai":
         messages = []
         if system:

src/create_context_graph/ontology.py

@@ -238,9 +238,15 @@ def _merge_base(base: dict, domain_data: dict) -> dict:
 
 def load_domain(domain_id: str) -> DomainOntology:
     """Load a domain ontology by ID, merging with base definitions."""
+    # Check main domains directory first, then custom domains
     domains_dir = _get_domains_path()
     domain_path = domains_dir / f"{domain_id}.yaml"
-
+    
+    if not domain_path.exists():
+        # Try custom domains directory
+        custom_domains_dir = _get_custom_domains_path()
+        domain_path = custom_domains_dir / f"{domain_id}.yaml"
+    
     if not domain_path.exists():
         raise FileNotFoundError(f"Domain ontology not found: {domain_id}")
 

src/create_context_graph/renderer.py

@@ -109,6 +109,7 @@ def _context(self) -> dict:
             "neo4j_password": self.config.neo4j_password,
             "neo4j_type": self.config.neo4j_type,
             "anthropic_api_key": self.config.anthropic_api_key or "",
+            "anthropic_base_url": self.config.anthropic_base_url or "",
             "openai_api_key": self.config.openai_api_key or "",
             "google_api_key": self.config.google_api_key or "",
             "system_prompt": self.ontology.system_prompt,
@@ -203,7 +204,7 @@ def _render_backend(self, backend_dir: Path, ctx: dict) -> None:
         agent_template = f"backend/agents/{fw_key}/agent.py.j2"
         try:
             self._render_template(agent_template, backend_dir / "app" / "agent.py", ctx)
-        except Exception:
+        except Exception as e:
             # Fallback: render a minimal agent stub
             self._render_template(
                 "backend/shared/agent_stub.py.j2",
@@ -300,6 +301,8 @@ def _render_cypher(self, cypher_dir: Path, ctx: dict) -> None:
 
     def _render_data(self, data_dir: Path, ctx: dict) -> None:
         """Copy ontology and create data directory structure."""
+        from create_context_graph.ontology import _get_domains_path
+        
         data_dir.mkdir(parents=True, exist_ok=True)
         (data_dir / "documents").mkdir(exist_ok=True)
 
@@ -308,8 +311,6 @@ def _render_data(self, data_dir: Path, ctx: dict) -> None:
             # Write custom domain YAML directly
             (data_dir / "ontology.yaml").write_text(self.config.custom_domain_yaml)
         else:
-            from create_context_graph.ontology import _get_domains_path
-
             domain_yaml = _get_domains_path() / f"{self.config.domain}.yaml"
             if domain_yaml.exists():
                 shutil.copy2(domain_yaml, data_dir / "ontology.yaml")

src/create_context_graph/templates/backend/agents/anthropic_tools/agent.py.j2

@@ -19,6 +19,13 @@ if not os.environ.get("ANTHROPIC_API_KEY"):
         _key = dotenv_values("../.env").get("ANTHROPIC_API_KEY", "")
         if _key:
             os.environ["ANTHROPIC_API_KEY"] = _key
+
+# Set ANTHROPIC_BASE_URL if configured
+{% endraw %}
+{% if anthropic_base_url %}
+os.environ["ANTHROPIC_BASE_URL"] = "{{ anthropic_base_url }}"
+{% endif %}
+{% raw %}
 {% endraw %}
 
 import anthropic

src/create_context_graph/templates/backend/agents/claude_agent_sdk/agent.py.j2

@@ -21,7 +21,11 @@ IMPORTANT: You MUST use the available tools to query the knowledge graph before
 
 CRITICAL: Call tools DIRECTLY without any introductory text. Do NOT say "I'll search for..." or "Let me look up..." before calling a tool — just call the tool immediately. Only generate text AFTER you have received the tool results and are ready to provide your final answer."""
 
-client = anthropic.AsyncAnthropic(api_key=settings.anthropic_api_key)
+client_kwargs = {"api_key": settings.anthropic_api_key}
+{% if anthropic_base_url %}
+client_kwargs["base_url"] = "{{ anthropic_base_url }}"
+{% endif %}
+client = anthropic.AsyncAnthropic(**client_kwargs)
 
 # ---------------------------------------------------------------------------
 # Tool definitions for {{ domain.name }}

src/create_context_graph/templates/backend/agents/langgraph/agent.py.j2

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import uuid
 
+import langgraph
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
 from langgraph.prebuilt import create_react_agent
@@ -41,7 +42,6 @@ async def {{ tool.name }}({% for param in tool.parameters %}{{ param.name }}: {{
 
 {% endfor %}
 
-{% raw %}
 @tool
 async def run_cypher(query: str, parameters: str = "{}") -> str:
     """Execute a read-only Cypher query against the knowledge graph."""
@@ -56,13 +56,11 @@ async def run_cypher(query: str, parameters: str = "{}") -> str:
     except Exception as e:
         return json.dumps({"error": f"Cypher query failed: {e}"})
 
-
 @tool
 async def get_graph_schema() -> str:
     """Get the knowledge graph schema (node labels and relationship types)."""
     result = await get_schema()
     return json.dumps(result, default=str)
-{% endraw %}
 
 TOOLS = [
 {% for tool in agent_tools %}
@@ -72,10 +70,12 @@ TOOLS = [
     get_graph_schema,
 ]
 
-{% raw %}
 model = ChatAnthropic(
     model="claude-sonnet-4-20250514",
     api_key=settings.anthropic_api_key,
+{% if anthropic_base_url %}
+    base_url="{{ anthropic_base_url }}",
+{% endif %}
 )
 
 graph = create_react_agent(model, TOOLS, prompt=SYSTEM_PROMPT)
@@ -178,4 +178,3 @@ async def handle_message_stream(message: str, session_id: str | None = None) ->
         "session_id": session_id,
         "graph_data": None,
     }
-{% endraw %}

src/create_context_graph/templates/backend/agents/pydanticai/agent.py.j2

@@ -20,6 +20,13 @@ if not os.environ.get("ANTHROPIC_API_KEY"):
         _key = dotenv_values("../.env").get("ANTHROPIC_API_KEY", "")
         if _key:
             os.environ["ANTHROPIC_API_KEY"] = _key
+
+# Set ANTHROPIC_BASE_URL if configured
+{% endraw %}
+{% if anthropic_base_url %}
+os.environ["ANTHROPIC_BASE_URL"] = "{{ anthropic_base_url }}"
+{% endif %}
+{% raw %}
 {% endraw %}
 
 from pydantic_ai import Agent, RunContext