knowledge-worker 0.6.0__py3-none-any.whl

knowledge_worker-0.6.0.dist-info/METADATA

@@ -0,0 +1,365 @@
+Metadata-Version: 2.4
+Name: knowledge-worker
+Version: 0.6.0
+Summary: Provenance-backed personal knowledge graph for local AI workflows
+Author-email: Rahul Rangarao <rahulmranga@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rahulmranga/knowledge-worker
+Project-URL: Repository, https://github.com/rahulmranga/knowledge-worker
+Project-URL: Issues, https://github.com/rahulmranga/knowledge-worker/issues
+Keywords: knowledge-graph,llm-memory,local-first,provenance,personal-knowledge-management,ai,claude
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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 :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: rdf
+Requires-Dist: rdflib>=7.0.0; extra == "rdf"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.39.0; extra == "anthropic"
+Requires-Dist: rdflib>=7.0.0; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.68.0; extra == "openai"
+Requires-Dist: rdflib>=7.0.0; extra == "openai"
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.39.0; extra == "llm"
+Requires-Dist: openai>=1.68.0; extra == "llm"
+Requires-Dist: rdflib>=7.0.0; extra == "llm"
+Provides-Extra: ollama
+Requires-Dist: httpx>=0.27.0; extra == "ollama"
+Requires-Dist: rdflib>=7.0.0; extra == "ollama"
+Provides-Extra: proxy
+Requires-Dist: fastapi>=0.110.0; extra == "proxy"
+Requires-Dist: httpx>=0.27.0; extra == "proxy"
+Requires-Dist: mcp[cli]>=1.0.0; extra == "proxy"
+Requires-Dist: uvicorn[standard]>=0.27.0; extra == "proxy"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.39.0; extra == "all"
+Requires-Dist: openai>=1.68.0; extra == "all"
+Requires-Dist: httpx>=0.27.0; extra == "all"
+Requires-Dist: rdflib>=7.0.0; extra == "all"
+Dynamic: license-file
+
+# knowledge-worker
+
+[![PyPI](https://img.shields.io/pypi/v/knowledge-worker.svg)](https://pypi.org/project/knowledge-worker/)
+
+**A personal knowledge graph that survives between AI conversations.**  
+User-centered (not conversation-centered). Provenance-or-bust. Built on boring infrastructure.
+
+> *Your AI is only as smart as what it remembers about you.*
+
+<p align="center">
+  <img src="docs/assets/knowledge-worker-demo.gif" alt="knowledge-worker graph visualizer demo" width="900">
+</p>
+
+`knowledge-worker` is a local-first personal knowledge graph for carrying context across AI sessions. It turns notes into reviewable concepts, decisions, goals, and relationships, keeps source excerpts attached, and exports compact context you can paste into Claude, GPT, Ollama, or any other LLM workflow.
+
+Your private graph stays on your machine, enabling you to preserve the thread of your own reasoning across AI sessions.
+
+## Why
+
+AI conversations usually start from zero. You clarify a decision, name a constraint, sketch a goal, and then the next session forgets it. RAG can be heavy, full-note prompts are noisy, and most note apps do not plug cleanly into chat workflows.
+
+Stop dumping context. Build memory. `knowledge-worker` turns chats, notes, decisions, and sources into a local provenance-backed knowledge graph, then uses graph analytics to show what matters, what connects, what is weak, and what context an AI should see.
+
+`knowledge-worker` keeps the useful parts: cited claims, explicit relationships, human review, and a small context snapshot when you need continuity.
+
+## How It Compares
+
+`knowledge-worker` is personal AI memory with source-backed claims, not a team
+chat-to-wiki system. It keeps reasoning local, reviewable, and tied to literal
+provenance excerpts before claims become durable graph knowledge.
+
+See [Competitive Analysis](docs/COMPETITIVE_ANALYSIS.md) for the category
+matrix and [Benchmarks](docs/BENCHMARKS.md) for the offline demo-graph checks.
+
+## What It Does
+
+- Ingests markdown notes into candidate graph nodes and edges.
+- Requires provenance excerpts before claims become durable memory.
+- Lets you review, accept, reject, or edit LLM proposals before merge.
+- Searches by term, lists nodes by type, and finds paths between ideas.
+- Exports an LLM-ready context snapshot for a fresh chat session.
+- Audits memory shape with PageRank, betweenness, k-core, communities, weak
+  claims, and provenance coverage.
+- Generates an offline HTML graph viewer for exploration and demos.
+
+## Design Principles
+
+**Provenance first.** Every durable claim points back to a source document and literal excerpt.
+
+**Local first.** The graph is a file on your machine. No cloud sync, accounts, or telemetry.
+
+**Review before merge.** The LLM proposes. You decide. Deterministic validation runs before anything enters the graph.
+
+**Boring persistence.** Plain JSON until it becomes the limiting factor. The schema stays stable across storage backends.
+
+## Quick Start
+
+Requirements: Python 3.10+ on macOS, Linux, or Windows.
+
+### Install from PyPI
+
+The core CLI has no runtime dependencies beyond the standard library. Optional
+extras pull in LLM backends and RDF export only when you need them:
+
+```bash
+python -m pip install knowledge-worker               # core CLI, stdlib only (mykg / mygraph)
+python -m pip install "knowledge-worker[rdf]"        # + Turtle/RDF export (rdflib)
+python -m pip install "knowledge-worker[anthropic]"  # + Claude-backed ingest
+python -m pip install "knowledge-worker[openai]"     # + OpenAI-backed ingest
+python -m pip install "knowledge-worker[ollama]"     # + local Ollama ingest
+python -m pip install "knowledge-worker[all]"        # all ingest backends + RDF
+```
+
+Verify the install (no clone needed — `seed` generates its own demo graph):
+
+```bash
+mykg --help
+MYGRAPH_PATH=/tmp/knowledge-worker-demo.json mykg seed
+MYGRAPH_PATH=/tmp/knowledge-worker-demo.json mykg summary
+```
+
+Using a virtual environment avoids Homebrew/system Python's externally-managed
+install errors:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install knowledge-worker
+```
+
+### Run from a clone (no install)
+
+The core demo CLI uses only the standard library, so you can run it straight
+from a checkout without installing anything:
+
+```bash
+git clone https://github.com/rahulmranga/knowledge-worker
+cd knowledge-worker
+
+# Run the public demo graph, no API key needed
+MYGRAPH_PATH=examples/demo_graph.json python3 mygraph/mygraph.py summary
+MYGRAPH_PATH=examples/demo_graph.json python3 mygraph/mygraph.py query "provenance"
+
+# Generate an LLM-ready context snapshot
+MYGRAPH_PATH=examples/demo_graph.json python3 mygraph/mygraph.py context
+
+# Audit memory structure and proof coverage
+MYGRAPH_PATH=examples/demo_graph.json python3 mygraph/mygraph.py audit --out /tmp/analytics.json --html /tmp/memory_audit.html
+
+# Visualize the graph as a self-contained HTML file
+python3 mygraph/mygraph.py viz --graph examples/demo_graph.json --out /tmp/demo.html
+```
+
+For the shorter `mykg` command from a clone, install it editable inside a
+virtual environment:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+MYGRAPH_PATH=examples/demo_graph.json mykg query provenance
+```
+
+On Windows PowerShell:
+
+```powershell
+py -3 -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install knowledge-worker
+
+$env:MYGRAPH_PATH = "$env:TEMP\knowledge-worker-demo.json"
+mykg seed
+mykg summary
+```
+
+From a clone, install editable instead:
+
+```powershell
+python -m pip install -e .
+
+$env:MYGRAPH_PATH = "examples\demo_graph.json"
+mykg query provenance
+mykg audit --out "$env:TEMP\analytics.json" --html "$env:TEMP\memory_audit.html"
+```
+
+If PowerShell blocks activation scripts, run this for the current terminal
+session and activate again:
+
+```powershell
+Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
+```
+
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `seed` | Populate a fictional demo graph |
+| `summary` | Show node and edge counts by type |
+| `query <term>` | Search nodes, neighbors, and provenance |
+| `list <type>` | List nodes of a given type |
+| `path <a> <b>` | Find the shortest path between two nodes |
+| `ingest <file.md>` | Extract, validate, review, merge, and eval candidates |
+| `check --provenance` | Flag nodes with missing source citations |
+| `export --ttl` | Emit Turtle/RDF |
+| `context` | Print a compact LLM-ready context snapshot |
+| `viz` | Generate an offline single-file HTML viewer |
+| `audit` | Emit graph analytics, directed idea-flow queues, and optional Memory Audit HTML |
+| `discover` | Propose derived edges and second-order insights (read-only, promotion queue) |
+| `state "<entry>"` | Append a mood/state sidecar entry |
+| `dump` | Print the raw graph JSON |
+| `reset` | Delete the active graph file |
+
+
+## Use Your Own Notes
+
+You can ingest your notes with or without an API key.
+
+### Claude or Codex App, No API Key
+
+If you are already working with Claude, Codex, or ChatGPT in an app session, you do **not** need an API key. Ask the assistant to produce a `*.candidates.json` file that follows the schema in `mygraph/extractor.py`, then let the local CLI validate, review, and merge it. In Claude Code, the bundled [`/ingest-notes`](.claude/skills/ingest-notes/SKILL.md) skill runs this flow for you:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e .
+
+mykg ingest path/to/your/notes.md --candidates-file path/to/your/notes.candidates.json
+```
+
+The app subscription helps you create the candidates file. The repo still keeps graph validation and merge local.
+
+### Automated API-Backed Ingest
+
+If you want the CLI to call an LLM directly, use a provider API key or local Ollama.
+
+For Anthropic API:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e ".[anthropic]"
+export ANTHROPIC_API_KEY=...
+
+mykg ingest path/to/your/notes.md
+```
+
+The Claude backend also auto-detects Anthropic-compatible provider env:
+
+- Anthropic API: `ANTHROPIC_API_KEY` or `ANTHROPIC_AUTH_TOKEN`
+- Foundry: `ANTHROPIC_FOUNDRY_API_KEY` plus `ANTHROPIC_FOUNDRY_RESOURCE` or `ANTHROPIC_FOUNDRY_BASE_URL`
+- Bedrock: `AWS_BEARER_TOKEN_BEDROCK`, or AWS credentials plus `AWS_REGION`/`AWS_DEFAULT_REGION`
+
+For OpenAI API:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e ".[openai]"
+export OPENAI_API_KEY=...
+
+mykg ingest path/to/your/notes.md --backend openai --model gpt-5.2
+```
+## Graph Workflow
+
+The public repo ships code, docs, and a fictional demo graph. Your real graph should live outside the repo or in the ignored default path, then be loaded explicitly:
+
+```bash
+MYGRAPH_PATH=~/my-private-graph/mygraph.json mykg summary
+MYGRAPH_PATH=~/my-private-graph/mygraph.json mykg query "architecture"
+MYGRAPH_PATH=~/my-private-graph/mygraph.json mykg context
+```
+
+Your private `mygraph.json`, generated private viewers, TTL exports, eval logs, state logs, and local env files are ignored by default.
+
+
+## Memory Audit
+
+`mykg audit` is a read-only layer over the graph. It ranks important concepts
+with PageRank, bridge ideas with betweenness, structural strength with k-core,
+communities with deterministic graph splitting, and weak claims from confidence
+and provenance gaps. It also includes directed idea-flow queues:
+`idea_attractors` for concepts that many edges point into, `idea_generators`
+for ideas that branch outward, and a `weak_claim_queue` that asks for human
+review actions instead of auto-promoting conclusions.
+
+```bash
+MYGRAPH_PATH=examples/demo_graph.json mykg audit \
+  --out /tmp/analytics.json \
+  --html /tmp/memory_audit.html
+```
+
+The generated HTML puts ranked panels and legwork queues first, with the graph
+canvas second. This keeps the feature focused on memory governance instead of
+making the raw graph view the product.
+
+## Discovery Layer
+
+Where `audit` ranks what the graph already says, `mykg discover` infers what it
+implies but does not yet say — and turns every inference into a reviewable
+proposal:
+
+- **Staleness radar**: important nodes whose evidence trail has gone cold,
+  scored by importance × days since the graph last touched them.
+- **Co-mention candidates**: pairs that recur together across multiple sources
+  but were never linked (`CO_MENTIONED_WITH`).
+- **Goal-alignment candidates**: ideas and decisions structurally entangled
+  with a goal they have no contribution path to (`SERVES_CANDIDATE`).
+- **Link prediction**: Adamic-Adar over the semantic graph (`RELATES_TO`).
+- **Question debt**: open questions ranked by age, centrality, and missing
+  evidence; answered questions are detected via decision `ABOUT` edges.
+- **Corroboration**: claims that hang on a single source (`SINGLE_SOURCE`).
+- **Bridge finder**: cross-community connectors that remain after removing
+  dominant hub "spines" that mask real bridges (`BRIDGES`).
+- **Tension detector**: claims that are both supported and challenged, and
+  goal contributions that inherit a challenge to the goal (`TENSION_WITH`).
+
+```bash
+MYGRAPH_PATH=examples/demo_graph.json mykg discover \
+  --out /tmp/discovery.json \
+  --candidates /tmp/discovery.candidates.json
+```
+
+Discover never mutates the graph. Derived edges land in a candidates file — a
+promotion queue for human review. AI proposes, provenance verifies, the owner
+promotes. Committed sample output: [`examples/demo_discovery.json`](examples/demo_discovery.json).
+
+## Local LLM Support
+
+The `ollama_proxy/` package adds three local-model surfaces:
+
+- `server.py`: MCP wrapper for Claude/Cowork-style tool use.
+- `proxy.py`: Ollama-compatible logging passthrough for HTTP clients.
+- `extractor_adapter.py`: drop-in extraction backend for `mykg ingest --backend ollama`.
+
+See [ollama_proxy/README.md](ollama_proxy/README.md) for setup.
+
+
+## Repository Layout
+
+```text
+mygraph/          Core CLI and pipeline modules
+examples/         Fictional demo graph, TTL, and HTML viewer
+docs/             Roadmap and public assets
+ollama_proxy/     Adapter, MCP server, and proxy for local Ollama workflows
+tests/            CLI smoke tests
+SPEC.md           Graph model specification
+DESIGN.md         Pipeline design notes
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). The core graph model is intentionally minimal; contributions that preserve that shape are preferred.
+
+## License
+
+MIT

knowledge_worker-0.6.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+knowledge_worker-0.6.0.dist-info/licenses/LICENSE,sha256=s82QuDIzTdGH65Kf32Mkc2GuRCGnrK2FL_adxFN3vJQ,1071
+mygraph/__init__.py,sha256=ptEn74xScDr6Uf6IA-iIh0D5txOWI22yiRBeMXRvbrc,468
+mygraph/anthropic_client.py,sha256=NbvBkfhRrNzIjhcFCCHogSrIS47S0iyqk5RHxCIqivA,6098
+mygraph/audit.py,sha256=RwBgQJzAEo_YBamslCtcaZvdp9Gdlc-n9B9HH0jlAPI,4352
+mygraph/check.py,sha256=kDkW2V8oJsPEwdA8OVfYAIVz_e5eEQzlVtW99rZ-IyE,9725
+mygraph/discover.py,sha256=wl9L9Gd9S5f26Ag8lcbcIYC8CzqPnHmiZj2FMqW-dJg,25700
+mygraph/eval_log.py,sha256=yKtK2a6C7NGFu79MK5ZNgurY_ECjEO3k3_i-hjTtrBI,1029
+mygraph/export_context.py,sha256=A6mVDg-NkYDJl2JA0VogLyj27Np_91XLu9Hl2cHY_fQ,4008
+mygraph/extractor.py,sha256=btCms_kUk9-IAF-5OxtFAuA2Bm2okL99Si3rL9P7tYw,8746
+mygraph/extractor_openai.py,sha256=vCTT68VGqgMsMDK0OqH_Z_kQZlpdp65Ypb4ZY0Rh-fI,5420
+mygraph/ingest.py,sha256=hDFhwedYXQcMKQcAN2wtgd6tqJ73tvtwFbcR3CwGZL8,6994
+mygraph/memory_audit.py,sha256=-H_dgGfZqbcbGn0Nv2Pci9nh-wONV_CE4AS7_vFYNuw,42877
+mygraph/merge.py,sha256=x2MTLaOa_2X7ii8jwD5s6Wm3A9WhDdeOJ5PDJwdRdN4,5225
+mygraph/mygraph.py,sha256=6XxZm2P0sqe0NPYhhaySbqwjCtDn8D-jqHFa2h516Ks,36680
+mygraph/owl_io.py,sha256=dKDWbgqikirXvW0aA1SKfzT5u25tl94FWkSzn14XQWg,7949
+mygraph/review.py,sha256=RtIb81whxSfZjGHUmph9i1TjocOFkOOlH3QupPb5Zq8,5499
+mygraph/validator.py,sha256=dej2eQGMKYzrTUhJEfcQOmeWKOh6Yvvp6FSMGr0kkHI,5511
+mygraph/viz.py,sha256=ipxlo4NtCcxUR5wlIF7nJrvG1nFVGXVwnr1dBWNA21c,17144
+ollama_proxy/eval_compare.py,sha256=B7pTPn8KPnAWX8UDBFJ4umZMqWbg0rHI9H38wsr6jPU,7429
+ollama_proxy/extractor_adapter.py,sha256=cqncBGnVnoWUALuDtnrIFR_6O0HQtrpDuf4KnJ7zma4,6026
+ollama_proxy/proxy.py,sha256=PIsfzXk2k9tKk2J725tXPopYehCfet63CdaEBWLCofM,5551
+ollama_proxy/server.py,sha256=WANSfjlIQBq5hWDLco3-xokZAGmsC3_zWDEJOmLmunE,6269
+knowledge_worker-0.6.0.dist-info/METADATA,sha256=ZiVE28j8OEl-BP91meNfB51u2a2oysG7igvuE63Arx8,14452
+knowledge_worker-0.6.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+knowledge_worker-0.6.0.dist-info/entry_points.txt,sha256=e0Y2M2JRv7j0TMlJmZr_5X2EFQWMih5sZeFhWoZbJI4,75
+knowledge_worker-0.6.0.dist-info/top_level.txt,sha256=muCRp1A8_-S-D_FUxyrEG0ZmApFUYTuahl81Bajnst4,21
+knowledge_worker-0.6.0.dist-info/RECORD,,

knowledge_worker-0.6.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

knowledge_worker-0.6.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mygraph = mygraph.mygraph:cli
+mykg = mygraph.mygraph:cli

knowledge_worker-0.6.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Rangarao
+
+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.

knowledge_worker-0.6.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mygraph
+ollama_proxy

mygraph/__init__.py

@@ -0,0 +1,23 @@
+"""Public package surface for the knowledge-worker graph toolkit."""
+
+__all__ = [
+    "CONFIDENCE",
+    "DEFAULT_GRAPH_PATH",
+    "EDGE_TYPES",
+    "GRAPH_PATH",
+    "NODE_TYPES",
+    "Edge",
+    "Graph",
+    "Node",
+    "nid",
+    "resolve_graph_path",
+    "slug",
+]
+
+
+def __getattr__(name):
+    if name not in __all__:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from . import mygraph as _core
+
+    return getattr(_core, name)

mygraph/anthropic_client.py

@@ -0,0 +1,199 @@
+"""
+Anthropic client selection for mygraph LLM-bound commands.
+
+The extractor and optional check probes support multiple Anthropic runtimes. Keep
+provider detection in one place so Bedrock and Foundry env vars are treated as
+valid Anthropic configuration, not as missing ANTHROPIC_API_KEY.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+_DOTENV_LOADED = False
+
+
+@dataclass(frozen=True)
+class AnthropicClientConfig:
+    provider: str
+    model: str
+
+
+def load_repo_env() -> None:
+    """Load repo-local .env values without overriding the process environment."""
+    global _DOTENV_LOADED
+    if _DOTENV_LOADED:
+        return
+    _DOTENV_LOADED = True
+
+    candidates = [
+        Path.cwd() / ".env",
+        Path(__file__).resolve().parent.parent / ".env",
+    ]
+    for env_path in candidates:
+        if not env_path.is_file():
+            continue
+        for raw_line in env_path.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("export "):
+                line = line[len("export "):].strip()
+            if "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip()
+            if not key or key in os.environ:
+                continue
+            os.environ[key] = _parse_env_value(value)
+        return
+
+
+def _parse_env_value(value: str) -> str:
+    value = value.strip()
+    if not value:
+        return ""
+    try:
+        parsed = shlex.split(value, comments=False, posix=True)
+    except ValueError:
+        return value.strip("\"'")
+    if len(parsed) == 1:
+        return parsed[0]
+    return value.strip("\"'")
+
+
+def _configured_provider() -> str:
+    explicit = (
+        os.environ.get("MYGRAPH_ANTHROPIC_PROVIDER")
+        or os.environ.get("ANTHROPIC_PROVIDER")
+        or ""
+    ).strip().lower()
+    aliases = {
+        "": "",
+        "auto": "",
+        "claude": "anthropic",
+        "default": "anthropic",
+        "native": "anthropic",
+        "anthropic": "anthropic",
+        "api": "anthropic",
+        "foundry": "foundry",
+        "azure": "foundry",
+        "azure-foundry": "foundry",
+        "bedrock": "bedrock",
+        "aws-bedrock": "bedrock",
+        "vertex": "vertex",
+        "google-vertex": "vertex",
+    }
+    if explicit not in aliases:
+        raise RuntimeError(
+            "unsupported Anthropic provider "
+            f"{explicit!r}; expected anthropic, foundry, bedrock, vertex, or auto"
+        )
+    provider = aliases[explicit]
+    if provider:
+        return provider
+
+    foundry_env = (
+        "ANTHROPIC_FOUNDRY_API_KEY",
+        "ANTHROPIC_FOUNDRY_RESOURCE",
+        "ANTHROPIC_FOUNDRY_BASE_URL",
+    )
+    if any(os.environ.get(name) for name in foundry_env):
+        return "foundry"
+
+    bedrock_specific_env = (
+        "AWS_BEARER_TOKEN_BEDROCK",
+        "ANTHROPIC_BEDROCK_BASE_URL",
+    )
+    if any(os.environ.get(name) for name in bedrock_specific_env):
+        return "bedrock"
+
+    anthropic_env = (
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_AUTH_TOKEN",
+        "ANTHROPIC_PROFILE",
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_IDENTITY_TOKEN",
+        "ANTHROPIC_IDENTITY_TOKEN_FILE",
+    )
+    if any(os.environ.get(name) for name in anthropic_env):
+        return "anthropic"
+
+    vertex_env = (
+        "CLOUD_ML_REGION",
+        "ANTHROPIC_VERTEX_BASE_URL",
+        "GOOGLE_APPLICATION_CREDENTIALS",
+    )
+    if any(os.environ.get(name) for name in vertex_env):
+        return "vertex"
+
+    has_aws_region = bool(os.environ.get("AWS_REGION") or os.environ.get("AWS_DEFAULT_REGION"))
+    has_aws_auth = bool(
+        os.environ.get("AWS_PROFILE")
+        or (os.environ.get("AWS_ACCESS_KEY_ID") and os.environ.get("AWS_SECRET_ACCESS_KEY"))
+    )
+    if has_aws_region and has_aws_auth:
+        return "bedrock"
+
+    return ""
+
+
+def _bedrock_kwargs() -> dict[str, str]:
+    if os.environ.get("AWS_PROFILE"):
+        return {"aws_profile": os.environ["AWS_PROFILE"]}
+    if os.environ.get("AWS_ACCESS_KEY_ID") and os.environ.get("AWS_SECRET_ACCESS_KEY"):
+        kwargs = {
+            "aws_access_key": os.environ["AWS_ACCESS_KEY_ID"],
+            "aws_secret_key": os.environ["AWS_SECRET_ACCESS_KEY"],
+        }
+        if os.environ.get("AWS_SESSION_TOKEN"):
+            kwargs["aws_session_token"] = os.environ["AWS_SESSION_TOKEN"]
+        return kwargs
+    return {}
+
+
+def anthropic_configured() -> bool:
+    load_repo_env()
+    return bool(_configured_provider())
+
+
+def get_anthropic_client() -> tuple[Any, AnthropicClientConfig]:
+    """Return a configured Anthropic-compatible client and its resolved config."""
+    load_repo_env()
+    try:
+        import anthropic  # type: ignore
+    except ImportError as e:
+        raise RuntimeError(
+            "the `anthropic` package is not installed. Run: pip install anthropic"
+        ) from e
+
+    provider = _configured_provider()
+    if not provider:
+        raise RuntimeError(
+            "no Anthropic provider configuration found. Set one of:\n"
+            "  - ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN\n"
+            "  - ANTHROPIC_FOUNDRY_API_KEY plus ANTHROPIC_FOUNDRY_RESOURCE or ANTHROPIC_FOUNDRY_BASE_URL\n"
+            "  - AWS_BEARER_TOKEN_BEDROCK or AWS credentials plus AWS_REGION/AWS_DEFAULT_REGION"
+        )
+
+    try:
+        if provider == "foundry":
+            client = anthropic.AnthropicFoundry()
+        elif provider == "bedrock":
+            client = anthropic.AnthropicBedrock(**_bedrock_kwargs())
+        elif provider == "vertex":
+            client = anthropic.AnthropicVertex()
+        else:
+            client = anthropic.Anthropic()
+    except Exception as e:
+        raise RuntimeError(
+            f"failed to construct Anthropic {provider} client from environment: {e}"
+        ) from e
+
+    model = os.environ.get("MYGRAPH_MODEL", "claude-sonnet-4-6")
+    return client, AnthropicClientConfig(provider=provider, model=model)