Skip to content
Back to search

samyama-graph

Rust graph-vector database: OpenCypher (99.9% of evaluated TCK scenarios pass), vector search, graph algorithms, RESP + HTTP. LDBC SNB Interactive and BI complete; 1B edges on one machine.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/samyama-ai/samyama-graph with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/samyama-ai/samyama-graph'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/samyama-ai--samyama-graph/badge.svg)](/listings/samyama-ai--samyama-graph)

HTML

<a href="/listings/samyama-ai--samyama-graph"><img src="/api/listings/samyama-ai--samyama-graph/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1 — Run with Docker Compose

**Step 1 — Prerequisites**

- ✅ Docker Desktop installed and running — [Watch setup video →](https://samyama.dev/videos) - ✅ No account or credentials needed — the image is public on GitHub Container Registry (`latest` is the newest release; pin a version such as `:1.11.0` for a reproducible setup)

**Step 2 — Pull the Docker image**

docker pull ghcr.io/samyama-ai/samyama-graph:latest

**Step 3 — Docker Compose setup**

Create a clean folder, then create `docker-compose.yml` inside it.

Linux & Mac:

mkdir -p samyama-graph
cd samyama-graph
touch docker-compose.yml

Windows (PowerShell):

mkdir C:\samyama-graph
cd C:\samyama-graph
notepad docker-compose.yml

> ℹ️ Replace `<your-openai-api-key>` with your actual key. Generate one at [platform.openai.com/api-keys](https://platform.openai.com/api-keys).

version: "3.9"
services:
  samyama-graph:
    image: ghcr.io/samyama-ai/samyama-graph:latest
    container_name: samyama-graph
    restart: unless-stopped
    ports:
      - "6379:6379"
      - "8080:8080"
    environment:
      EMBED_ENABLED: "true"
      EMBED_PROVIDER: openai
      EMBED_MODEL: text-embedding-3-small
      EMBED_API_KEY: <your-openai-api-key>
      EMBED_DIMENSION: 1024
    volumes:
      - samyama-data:/app/samyama_data
    networks:
      - samyama-network
networks:
  samyama-network:
    driver: bridge
volumes:
  samyama-data:

**Step 4 — Start the server**

docker compose up -d

Server will be available at http://localhost:8080

**Step 5 — Verify it's running**

docker ps
docker logs -f samyama-graph

You should see `samyama-graph` with status `Up`.

**Step 6 — Run your first query**

curl -X POST http://localhost:8080/api/query \
  -H 'content-type: application/json' \
  -d '{"query":"CREATE (a:Person {name: \"Alice\"})-[:KNOWS]->(b:Person {name: \"Bob\"}) RETURN a.name, b.name","graph":"default"}'
{"columns":["a.name","b.name"],"edges":[],"nodes":[],"records":[["Alice","Bob"]]}

Then read it back:

curl -X POST http://localhost:8080/api/query \
  -H 'content-type: application/json' \
  -d '{"query":"MATCH (a:Person)-[:KNOWS]->(b:Person) RETURN a.name, b.name","graph":"default"}'

**Parameters.** A runtime value goes in `params`, not in the query text:

curl -X POST http://localhost:8080/api/query \
  -H 'content-type: application/json' \
  -d '{"query":"MATCH (p:Person) WHERE p.name = $name RETURN p.name","params":{"name":"Alice"}}'

The values are bound, so a value is never re-read as Cypher — `{"name": "' OR 1=1 --"}` matches a person with that name and nothing else. JSON integers, floats, booleans, strings, `null`, lists and nested objects all map through; a number too large for an `i64` is refused rather than silently converted. A key the query never mentions is refused too, because ignoring it would drop a typo in silence. The same values go over RESP as trailing pairs: `GRAPH.QUERY default "MATCH (p:Person) WHERE p.name = $name RETURN p.name" name Alice`.

**Step 7 — Samyama Visualizer**

Visualize your imported graph data using the Samyama cloud visualizer at https://graph.samyama.cloud/

The visualizer is a page on the public web calling a server on your machine, so the server has to name it. Start Samyama with the origin allowed:

samyama --cors-origin https://graph.samyama.cloud

or `SAMYAMA_CORS_ORIGINS=https://graph.samyama.cloud`. Without it the browser refuses the call. **This is deliberate** — `/api/query` runs arbitrary Cypher including `DELETE`, so until v1.9 any web page you happened to visit could drive it ([#1328](https://github.com/samyama-ai/samyama-graph/issues/1328)). The server also listens on loopback unless `--host` says otherwise.

To require a credential as well:

samyama auth-token ops >> credentials     # prints the token once; store the line

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 384 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p align="center">
  2. <h1 align="center">Samyama Graph</h1>
  3. <p align="center">A Rust-native graph-vector database for GraphRAG, knowledge graphs, and billion-edge analytics.</p>
  4. <p align="center">
  5. <strong>99.9% of the openCypher TCK's evaluated scenarios pass · LDBC SNB Interactive 21/21 and BI 20/20, no timeouts · 1B edges on one machine</strong>
  6. </p>
  7. <p align="center">
  8. <a href="https://github.com/samyama-ai/samyama-graph/releases"><img src="https://img.shields.io/badge/version-1.16.0-blue" alt="Version"></a>
  9. <a href="https://github.com/samyama-ai/samyama-graph/actions/workflows/ci.yml"><img src="https://github.com/samyama-ai/samyama-graph/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  10. <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache_2.0-blue" alt="License"></a>
  11. <a href="https://graph.samyama.cloud/book/"><img src="https://img.shields.io/badge/book-read_the_docs-orange" alt="Book"></a>
  12. <a href="https://chat.whatsapp.com/Jjjkb3uWRDi1YMdfffaD9d"><img src="https://img.shields.io/badge/community-WhatsApp-25D366?logo=whatsapp&logoColor=white" alt="WhatsApp Community"></a>
  13. </p>
  14. </p>
  15. ---
  16. ## What it is
  17. Samyama Graph stores, queries, searches and analyses connected data in one
  18. system: graph traversal, openCypher-style querying, HNSW vector search, graph
  19. algorithms and Redis-compatible access, with no separate vector store to keep in
  20. sync.
  21. People use it for GraphRAG, knowledge graphs, AI-agent memory, biomedical and
  22. clinical graphs, and fraud, investigation and dependency analysis. The two demos
  23. below are the short version of why.
  24. ## Quickstart
  25. ### Docker
  26. The image is public on GitHub Container Registry and needs no registry account.
  27. `latest` is the newest release; pin a version such as `:1.16.0` for a
  28. reproducible setup.
  29. **1 — Write `docker-compose.yml`** in an empty folder:
  30. ```yaml
  31. services:
  32. samyama-graph:
  33. image: ghcr.io/samyama-ai/samyama-graph:latest
  34. container_name: samyama-graph
  35. restart: unless-stopped
  36. ports:
  37. - "6379:6379" # RESP (Redis protocol)
  38. - "8080:8080" # HTTP API
  39. environment:
  40. # Lets the hosted visualizer (step 4) call this server from your browser.
  41. SAMYAMA_CORS_ORIGINS: https://graph.samyama.cloud
  42. volumes:
  43. - samyama-data:/app/samyama_data
  44. volumes:
  45. samyama-data:
  46. ```
  47. **2 — Start it**
  48. ```bash
  49. docker compose up -d
  50. docker logs -f samyama-graph # Ctrl-C to stop following the log
  51. ```
  52. **3 — Run your first query**
  53. ```bash
  54. curl -X POST http://localhost:8080/api/query \
  55. -H 'content-type: application/json' \
  56. -d '{"query":"CREATE (a:Person {name: \"Alice\"})-[:KNOWS]->(b:Person {name: \"Bob\"}) RETURN a.name, b.name","graph":"default"}'
  57. ```
  58. ```json
  59. {"columns":["a.name","b.name"],"edges":[],"nodes":[],"records":[["Alice","Bob"]]}
  60. ```
  61. Runtime values go in `params`, never in the query text — they are bound, so a
  62. value is never re-read as Cypher:
  63. ```bash
  64. curl -X POST http://localhost:8080/api/query \
  65. -H 'content-type: application/json' \
  66. -d '{"query":"MATCH (p:Person) WHERE p.name = $name RETURN p.name","params":{"name":"Alice"}}'
  67. ```
  68. **4 — Explore it visually (optional).** Open <https://graph.samyama.cloud/>,
  69. click **Home**, enter `http://localhost:8080` and **Connect**. Without the
  70. `SAMYAMA_CORS_ORIGINS` line above the browser refuses the call — deliberately,
  71. because `/api/query` runs arbitrary Cypher including `DELETE`
  72. ([#1328](https://github.com/samyama-ai/samyama-graph/issues/1328)).
  73. **5 — Stop or reset.** `docker compose down` stops it; `docker compose down -v`
  74. also deletes the graph data in the volume.
  75. The server needs no credential by default. For a bearer token, TLS or
  76. auto-embedding, see [docs/DATA-HANDLING.md](docs/DATA-HANDLING.md).
  77. ### Build from source
  78. `zstd-sys` generates its bindings with `bindgen`, which needs libclang; without
  79. it the build fails part-way with a misleading `'stddef.h' file not found`.
  80. ```bash
  81. # Debian / Ubuntu
  82. sudo apt-get install -y build-essential cmake pkg-config libssl-dev clang libclang-dev
  83. # Fedora / RHEL
  84. sudo dnf install -y gcc gcc-c++ cmake pkgconf-pkg-config openssl-devel clang clang-devel
  85. # macOS — the Xcode Command Line Tools already provide clang
  86. xcode-select --install
  87. ```
  88. Then, with a stable Rust toolchain from [rustup](https://rustup.rs/):
  89. ```bash
  90. git clone https://github.com/samyama-ai/samyama-graph && cd samyama-graph
  91. cargo build --release
  92. ./target/release/samyama # RESP on :6379, HTTP on :8080
  93. # Connect with any Redis client
  94. redis-cli -p 6379
  95. GRAPH.QUERY mydb "CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})"
  96. GRAPH.QUERY mydb "MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name"
  97. ```
  98. ### Clients
  99. | Language | Install | Connect |
  100. |----------|---------|---------|
  101. | Python | `pip install samyama` | `SamyamaClient.connect("http://localhost:8080")`, or `SamyamaClient.embedded()` to run the engine in-process |
  102. | TypeScript | `npm install samyama-sdk` | `SamyamaClient.connectHttp("http://localhost:8080")` (ESM, Node 18+) |
  103. | Rust | `samyama-sdk = { git = "https://github.com/samyama-ai/samyama-graph", tag = "v1.16.0" }` — `samyama-sdk` is not on crates.io yet | `RemoteClient` over HTTP, or `EmbeddedClient::new()` in-process |
  104. Any Redis client also works over RESP on port 6379. Details:
  105. [Python](sdk/python/README.md) · [TypeScript](sdk/typescript/README.md) ·
  106. [Rust](crates/samyama-sdk/README.md).
  107. ## Two demos
  108. ### 1. Four public datasets, one graph, one query
  109. We loaded the entire PubMed corpus plus ClinicalTrials.gov, Reactome pathways and
  110. DrugBank into **one graph** — 74M nodes, 1B edges on a single machine — then
  111. asked *"what drugs are most tested in cancer clinical trials?"*
  112. ```cypher
  113. MATCH (m:MeSHTerm)<-[:ANNOTATED_WITH]-(a:Article)
  114. -[:REFERENCED_IN]->(t:ClinicalTrial)-[:TESTS]->(i:Intervention)
  115. WHERE m.name = 'Neoplasms'
  116. RETURN i.name, count(DISTINCT t) AS trials
  117. ORDER BY trials DESC LIMIT 5
  118. ```
  119. | Drug | Trials |
  120. |------|--------|
  121. | **Placebo** | **521** |
  122. | Pembrolizumab | 137 |
  123. | Carboplatin | 106 |
  124. | Paclitaxel | 106 |
  125. | Cyclophosphamide | 98 |
  126. **10.3 seconds.** One query. Four databases. No ETL between the four sources —
  127. they are joined at query time on shared identifiers.
  128. That is query `XK02`: 10,250.2 ms in
  129. [`verified-results.csv`](https://graph.samyama.cloud/book/data/benchmark/verified-results.csv),
  130. measured 2026-04-02 on one r6a.8xlarge and not re-measured since. 96 of the 100
  131. queries in that suite return real data. Per-row provenance and caveats are in
  132. [docs/BENCHMARKS.md](docs/BENCHMARKS.md#biomedical-scale-and-cross-kg-queries).
  133. | ID | Query | Time | First row (CSV) |
  134. |----|-------|------|-----------------|
  135. | XK02 | Cancer → Trial interventions | 10.3s | Placebo (521 trials) |
  136. | XK07 | Cancer trial sites by country | 4.2s | United States (4,062) |
  137. | XK08 | NCI-funded → Trial interventions | 20.5s | Placebo (933) |
  138. [See all 100 queries →](https://graph.samyama.cloud/book/biomedical_benchmark.html)
  139. ### 2. A real knowledge graph in one command
  140. [`case_studies/`](case_studies) downloads a public knowledge graph, imports it,
  141. runs showcase Cypher and renders the session as a narrated GIF. Every showcase
  142. query is gated to return real rows
  143. ([Definition of Done](case_studies/DEFINITION_OF_DONE.md)).
  144. ```bash
  145. cargo build --release && pip install rich requests
  146. cd case_studies/cricket && ./run.sh # fetch snapshot → import → validate → demo
  147. ```
  148. > Cricket KG — 36,619 nodes, 1,392,017 edges, live graph simulation
  149. [![Samyama Graph Simulation](https://github.com/samyama-ai/samyama-graph/releases/download/kg-snapshots-v2/simulation-preview.gif)](https://github.com/samyama-ai/samyama-graph/releases/download/kg-snapshots-v2/samyama-cricket-demo.mp4)
  150. *Click for the full demo (1:56).*
  151. Ten more ship the same way — drug interactions, pathways, vector search over
  152. DBMS research, IMDB, surveillance, health determinants, health systems, legal
  153. judgments, bank model risk and football.
  154. [Browse the catalogue →](case_studies)
  155. ## What it can do
  156. **Cypher** — MATCH, CREATE, MERGE, aggregations, path finding, 30+ functions.
  157. 99.9% of the openCypher TCK's evaluated scenarios pass (3,845 of 3,847, at 98.7%
  158. coverage of the 3,897-scenario corpus, measured 2026-09-15) —
  159. [docs/CYPHER-COMPATIBILITY.md](docs/CYPHER-COMPATIBILITY.md).
  160. ```cypher
  161. MATCH p = shortestPath((a:Person)-[:KNOWS*1..3]->(b:Person))
  162. WHERE a.name = 'Alice'
  163. RETURN b.name, length(p)
  164. ```
  165. **Vector search** — HNSW indexing for semantic search and GraphRAG, in the same
  166. query language as the traversal. `quantization: 'fp16'` halves the index's
  167. memory.
  168. ```cypher
  169. CREATE VECTOR INDEX paper_idx FOR (p:Paper) ON (p.embedding)
  170. OPTIONS {dimensions: 384, similarity: 'cosine'}
  171. CALL db.index.vector.queryNodes('Paper', 'embedding', [0.1, 0.2, 0.3], 10)
  172. YIELD node, score
  173. ```
  174. **Graph algorithms** — PageRank, WCC, SCC, BFS, Dijkstra, LCC, CDLP, triangle
  175. count. PageRank, LCC, CDLP and triangle counting are Rayon-parallel and scale
  176. with cores; WCC, betweenness and closeness run on one thread.
  177. ```cypher
  178. CALL pagerank('social') YIELD nodeId, score
  179. RETURN nodeId, score ORDER BY score DESC LIMIT 10
  180. ```
  181. **Natural language and AI agents** — `NLQ "Who are Alice's friends of friends
  182. that work at Google?"` translates English to Cypher through an LLM. For agents,
  183. MCP servers are generated from your graph schema: `pip install samyama[mcp]`,
  184. then `samyama-mcp-serve --demo cricket`.
  185. **Operational basics** — `BEGIN` / `COMMIT` / `ROLLBACK` over RESP and HTTP with
  186. a published isolation table ([docs/ACID-GUARANTEES.md](docs/ACID-GUARANTEES.md));
  187. any read query out as Arrow or Parquet via `POST /api/query/export`
  188. ([docs/BI-CONNECTIVITY.md](docs/BI-CONNECTIVITY.md)); Prometheus metrics at
  189. `/metrics` with a [Grafana dashboard](ops/grafana/); GPU acceleration via wgpu or
  190. CUDA (`--features gpu` / `--features cuda`).
  191. ## Measured results
  192. Every headline number is re-measured on a schedule by a conformance harness that
  193. publishes `SCORECARD.json`, and a regression gate blocks the release tag on a
  194. stale or red verdict. Run the suites yourself with `cargo bench --bench <name>`
  195. ([`benches/`](benches)); the vector, optimization and micro/MVCC suites are
  196. self-contained, LDBC needs a data download.
  197. | Suite | Result |
  198. |-------|--------|
  199. | openCypher TCK | 3,845 / 3,847 evaluated scenarios, 98.7% corpus coverage (2026-09-15) |
  200. | LDBC SNB Interactive (SF1) | 21/21 complete, 21/21 return rows (`CH-BENCH-LDBC`) |
  201. | LDBC SNB BI (SF1) | 20/20 complete, 0 timeouts (`CH-BENCH-LDBC`) |
  202. | LDBC Graphalytics | 12/12 agree with the LDBC reference (`CH-BENCH-GALX`) |
  203. | HIER (subsumption and roll-up) | Latest: **108/108 agree** — `benches/hier/results/PROVENANCE.json`, engine commit `30d0731` with `"dirty": true`, so it is not a reproducible commit; 4 further corpus queries are specified but uncontrolled and are not in that denominator. Covers ground LDBC and FinBench do not |
  204. | Memory | 200 resident bytes per edge on SNB SF10, 176M edges (`CH-MEM-01`, against a 256 B/edge target) |
  205. | Cross-KG biomedical | 96 / 100 queries return real data, measured 2026-04-02 — the first demo above |
  206. These run in-tree; LDBC certification is a formal third-party process we have not
  207. been through. Full results, provenance and caveats:
  208. **[docs/BENCHMARKS.md](docs/BENCHMARKS.md)**.
  209. ## Knowledge graphs
  210. Twenty-six public knowledge graphs are built for Samyama, each in its own
  211. repository with its loader and source-data notes. They are what the demos above
  212. and the research below are measured on.
  213. | How to get one | Count |
  214. |---|---|
  215. | Prebuilt download — HuggingFace dataset and/or `.sgsnap` snapshot | 17 |
  216. | Build it yourself from the repository's loader | 8 |
  217. | Not published yet | 1 |
  218. The biomedical set — `pubmed-kg` (66M nodes / 1.04B edges), `clinicaltrials-kg`,
  219. `pathways-kg`, `druginteractions-kg`, `surveillance-kg`,
  220. `health-determinants-kg`, `health-systems-kg` and more — is what the federation
  221. demo composes. Beyond biomedicine there are security and IT-ops graphs
  222. (`mitre-attack-kg`, `nvd-cve-kg`, `d3fend-kg`), industrial and financial ones
  223. (`assetops-kg`, `bank-model-risk-kg`, `powergrid-kg`, `telecom-kg`), and demo
  224. graphs (`cricket-kg`, `imdb-kg`, `football-kg`).
  225. **[docs/KG-CATALOG.md](docs/KG-CATALOG.md)** has every graph with its scale, data
  226. licence, download link and a query to start with. Each figure there is taken from
  227. that graph's own repository rather than restated, and every download link is
  228. checked on the date the page records.
  229. ## Papers
  230. Samyama's design and results are written up in eighteen arXiv preprints —
  231. fourteen `cs.DB`, two `cs.CL`, one `cs.LG` — under one
  232. [author listing](https://arxiv.org/a/mandarapu_m_1.html). Four describe the
  233. system and its applications directly:
  234. | Paper | arXiv |
  235. |---|---|
  236. | Samyama: A Unified Graph-Vector Database with In-Database Optimization, Agentic Enrichment, and Hardware Acceleration | [2603.08036](https://arxiv.org/abs/2603.08036) |
  237. | Open Biomedical Knowledge Graphs at Scale: Construction, Federation, and AI Agent Access | [2603.15080](https://arxiv.org/abs/2603.15080) |
  238. | Knowledge Graphs as the Missing Data Layer for LLM-Based Industrial Asset Operations | [2605.26874](https://arxiv.org/abs/2605.26874) |
  239. | Graph-Grounded Optimization: Rao-Family Metaheuristics, Classical OR, and SLM-Driven Formulation over Knowledge Graphs | [2605.12204](https://arxiv.org/abs/2605.12204) |
  240. The rest are focused results that came out of building the engine — when q-error
  241. predicts plan regret, filtered ANN as a phase transition, when to repair a graph
  242. ANN index (a matched-budget negative result), LSM bloom-filter tuning, a
  243. decode-throughput law for columnar scans, and a reference semantics for GQL and
  244. SQL/PGQ path patterns.
  245. Two agent-access results are worth calling out, because they compare MCP tools
  246. against text-to-Cypher on the same questions: **BiomedQA** (40 questions) scores
  247. MCP 98% · text-to-Cypher 85% · GPT-4o 75%, and **AssetOpsBench** (139 scenarios)
  248. scores MCP 99% · text-to-Cypher 83% · GPT-4 65%.
  249. **[Publication tracker →](https://graph.samyama.cloud/book/publication_tracker.html)**
  250. for the full list with revisions and venue status, and
  251. [a plain-language summary →](https://graph.samyama.cloud/book/research_paper_summary.html).
  252. Reproduction packages live in one repository per paper under the
  253. [`samyama-ai`](https://github.com/orgs/samyama-ai/repositories) organization.
  254. ## The ecosystem
  255. This repository is the engine. Around it:
  256. | | What it is |
  257. |---|---|
  258. | **The Book** | [graph.samyama.cloud/book](https://graph.samyama.cloud/book/) — the long-form documentation, benchmarks, KG catalog and papers |
  259. | **Visualizer** | [graph.samyama.cloud](https://graph.samyama.cloud/) — hosted browser UI; point it at your own server |
  260. | **Knowledge graphs** | 26 repositories, one per graph — [catalog](docs/KG-CATALOG.md) |
  261. | **[graphrag-rs](https://github.com/samyama-ai/graphrag-rs)** | Ingests a folder of docs, extracts entities and relationships with an LLM, then serves the result as an MCP server. **Builds** a graph, where `samyama[mcp]` **serves** one that exists |
  262. | **[biomedqa](https://github.com/samyama-ai/biomedqa)** | The 40-question pharmacology benchmark above, across three KGs |
  263. | **[optimization_algorithms](https://github.com/samyama-ai/optimization_algorithms)** | Rao-family metaheuristics, on PyPI as `rao-algorithms` — the optimizers behind `algo.or.solve` |
  264. | **Samyama Enterprise** | [samyama.dev](https://samyama.dev) — see below |
  265. A fuller map, including the private repositories and how versions are kept in
  266. step, is in
  267. [ecosystem architecture](https://graph.samyama.cloud/book/ecosystem_architecture.html).
  268. ## Enterprise Edition
  269. Everything in this repository is open source (Apache 2.0) — including GPU
  270. acceleration, Prometheus metrics and the request audit log (`--audit-log`).
  271. [Samyama Enterprise](https://samyama.dev) adds OpenTelemetry OTLP metrics, backup
  272. and disaster recovery, ADMIN commands, and Ed25519 signed license tokens.
  273. [Contact us →](https://samyama.dev/contact)
  274. ## Documentation
  275. | Resource | Link |
  276. |----------|------|
  277. | **The Book** | [graph.samyama.cloud/book](https://graph.samyama.cloud/book/) |
  278. | All documentation | [docs/README.md](docs/README.md) |
  279. | Examples and loaders — 127 programs, 19 domain demos, 15 data loaders | [examples/README.md](examples/README.md) |
  280. | Cypher compatibility | [docs/CYPHER-COMPATIBILITY.md](docs/CYPHER-COMPATIBILITY.md) |
  281. | Benchmarks | [docs/BENCHMARKS.md](docs/BENCHMARKS.md) |
  282. | Knowledge graph catalog | [docs/KG-CATALOG.md](docs/KG-CATALOG.md) |
  283. | Security, auth, TLS and data handling | [docs/DATA-HANDLING.md](docs/DATA-HANDLING.md) |
  284. | Migrating from Neo4j | [docs/MIGRATING-FROM-NEO4J.md](docs/MIGRATING-FROM-NEO4J.md) |
  285. | Migrating from FalkorDB or RedisGraph | [docs/MIGRATING-FROM-FALKORDB.md](docs/MIGRATING-FROM-FALKORDB.md) |
  286. | Failure modes | [docs/FAILURE-MODES.md](docs/FAILURE-MODES.md) |
  287. | Release notes | [docs/release-notes/](docs/release-notes/) |
  288. | Project layout | [CONTRIBUTING.md](CONTRIBUTING.md#project-layout) |
  289. | API spec | [openapi/openapi.yaml](openapi/openapi.yaml) |
  290. | Troubleshooting | [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) |
  291. ## Contributing
  292. Contributions are welcome — bug reports, docs, tests and code. See
  293. **[CONTRIBUTING.md](CONTRIBUTING.md)** for setup, build and test commands and the
  294. pull request workflow. Found a bug?
  295. [Open an issue](https://github.com/samyama-ai/samyama-graph/issues/new/choose).
  296. Questions? [Join the community chat](https://chat.whatsapp.com/Jjjkb3uWRDi1YMdfffaD9d).
  297. Every issue gets a first response within 2 business days
  298. ([SUPPORT.md](SUPPORT.md)); what is accepted for a date is in
  299. [ROADMAP.md](ROADMAP.md).
  300. ## License
  301. Apache License 2.0 — use it in production, contribute back if you'd like.
  302. **Samyama** (Sanskrit: संयम) — the union of focused query, sustained analysis, and unified insight.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.