Repository navigation
Traverse 0.9.0
Traverse 0.9.0 is the first open-source release, licensed under MIT OR Apache-2.0 at your option.
Downloads
| File | Contents |
|---|---|
traverse-0.9.0-x86_64-windows.zip |
Server, CLI, admin and bench tools for Windows x64 |
traverse-0.9.0-x86_64-linux.tar.gz |
The same for Linux x64 (glibc 2.34 or later) |
traverse-ffi-0.9.0-x86_64-windows.zip |
The native library with its C header, for Go and C, Windows x64 |
traverse-ffi-0.9.0-x86_64-linux.tar.gz |
The same for Linux x64 |
Docker: docker run -p 7690:7690 -p 7691:7691 -v traverse-data:/data truespar/traverse:0.9.0
(the generated API key is in docker logs).
Embedded SDKs: NuGet Traverse.Embedded, Maven com.truespar:traverse-java, PyPI
traverse-embedded, npm @truespar/traverse-node, Go github.com/truespar/traverse/go. HTTP
clients: NuGet Traverse.Http, Maven com.truespar:traverse-http, PyPI traverse-http, npm
@truespar/traverse-http, Go github.com/truespar/traverse/go/http. Also NuGet Traverse.Bolt
and Traverse.Grpc.
Verifying a download
-
The Windows
.exeand.dllfiles are Authenticode-signed by The Intelligence Company AB (publ). -
Every archive has a
.sha256next to it:sha256sum -c traverse-0.9.0-x86_64-linux.tar.gz.sha256 -
The Linux tarballs also have a detached GPG signature (
.asc) by key
5E12 4423 325C 3C6F FA3D 730D B737 2036 EF64 37DE:gpg --keyserver keyserver.ubuntu.com --recv-keys 5E124423325C3C6FFA3D730DB7372036EF6437DE gpg --verify traverse-0.9.0-x86_64-linux.tar.gz.asc traverse-0.9.0-x86_64-linux.tar.gz
Changes
Licensing removed
- Open source. Traverse is licensed under MIT OR Apache-2.0, at your option, and developed in the open at https://github.com/truespar/traverse. Every archive, the Docker image and every package (NuGet, Maven, npm, PyPI) include both licence texts; the ones that carry the engine also include
THIRD-PARTY-NOTICES, the components compiled into it. - No licence key, no limits. Traverse no longer asks for a licence key and no longer enforces plan limits. The 7-day trial, the activation flow, device registration, the database/node/edge/connection caps and the per-feature gates (user management, Graph Assistant) are gone; every feature is available to everyone.
--license-key/TRAVERSE_LICENSE_KEY/license_key, the/api/license/*endpoints and thelicenseblock of/api/healthhave been removed, as haveDatabase.OpenLicensed(.NET),Database.openLicensed(Java),traverse.open_licensed(Python) andopenLicensed(Node.js) - use the plainopen. - No version check. The server, CLI (
:update) andtraverse-admin updateno longer check online for new releases; theupdateblock of/api/healthand/api/update/downloadare gone. - No outside service. Nothing in Traverse calls home any more. A shared query link now carries the query itself (in the part of the URL after
#, which the browser never sends anywhere), so it works on any server and in the browser build; Studio's feedback form has been removed.--api-base/TRAVERSE_API_BASE/api_baseand the/api/feedbackand/api/share-queryendpoints have been removed.
Graph Assistant
- Bring your own model. Studio's Graph Assistant now talks to a model you configure:
ai_provider = "anthropic"(the Claude API,claude-opus-5-5by default) or"openai"for any OpenAI-compatible endpoint - OpenAI, Azure OpenAI, or a model on your own machine through Ollama, LM Studio or vLLM. Set it with--ai-provider,TRAVERSE_AI_PROVIDERortraverse.toml, plusai_api_key,ai_model,ai_base_url,ai_max_tokensandai_effort. The key stays on the server, and nothing leaves your network unless the provider you pick is a cloud one. Without a provider the assistant is off and Studio hides it;/api/healthreportsfeatures.ai, and the startup banner shows the model in use. - It knows the query language. The assistant writes GQL when the editor is set to GQL, and its instructions now cover GQL, the index and constraint types, transactions, the graph algorithms and Graph ML.
- Studio now shows why an answer stopped (the provider's error, a refusal, the output limit) instead of an empty reply.
Transactions
- Explicit transactions no longer copy the database or lose updates.
BEGIN ... COMMITover Bolt, gRPC transactions and the drivers' managed transactions now read a snapshot plus their own writes and apply everything at commit. Opening one is instant whatever the database size, an open transaction blocks no other reader or writer, and two transactions that change the same node or relationship no longer overwrite each other: the later commit fails withNeo.TransientError.Transaction.Outdated(gRPCABORTED), which the drivers retry automatically. ConcurrentMERGEs of the same unique key can no longer both create a node. Inwalmode explicit-transaction commits are logged like any other write. - Read-only transactions.
BEGINwithmode: "r"(driver read sessions) refuses writes. - A failed statement fails its transaction. In an explicit transaction over gRPC or in the embedded bindings, a statement that fails after it changed data (a constraint violation part way through, a stopped query) can't leave half its writes behind: later statements and the commit fail (gRPC
FAILED_PRECONDITION,TvErrorCode.Transaction,ErrTransaction,TV_ERROR_TRANSACTION,ERR_TRAVERSE_TRANSACTION_FAILED) and only a rollback ends it, as over Bolt. A statement that fails before writing anything, such as a syntax error, leaves the transaction usable. CALL { ... } IN TRANSACTIONScommits each batch. As an auto-commit statement (Bolt, HTTP, WebSocket, MCP, gRPC without a transaction, the browser build) every batch commits on its own as it completes, so a large import holds one batch of uncommitted changes at a time. WithON ERROR CONTINUEorBREAKa failed batch is rolled back and its rows dropped while earlier batches stay committed;REPORT STATUSgives each batch'sstarted,committed,transactionIdanderrorMessage. It's refused inside an explicit transaction and after writes in the same statement; in the embedded bindings run it with the auto-commitexecute(below). Previously the batches ran in the statement's one transaction and a failed batch's writes could be committed.- Browser queries are atomic. In the WebAssembly build each query is a transaction of its own: a write that fails or runs out of time leaves nothing behind, and the time limit covers the parallel phases on the browser's worker threads.
- Idle transactions are rolled back after
--tx-idle-timeout/TRAVERSE_TX_IDLE_TIMEOUT/tx_idle_timeoutseconds (default 60,0= no limit); the next message in the transaction fails withNeo.TransientError.Transaction.Terminated. - Consistent snapshots on every access path. A read sees exactly the transactions committed before it started - through label and relationship-type scans, property, relationship, vector, full-text, point and text index lookups, traversals and counts - including nodes and relationships changed or deleted since. Previously some paths could show a writer's uncommitted changes or miss entities changed after the read began. Graph algorithms run on a consistent snapshot while writes continue, instead of failing with "uncommitted writes are present".
- Fixed: rolling back a transaction that changed indexed properties could leave stale index entries; rolling back schema changes didn't restore vector, full-text, point and text indexes or relationship and composite constraints; composite indexes created in
walmode weren't recovered after a crash;r.prop IN [...]over an indexed relationship property could return wrong rows when repeated with other values; vector indexes skipped embeddings stored as native vectors; a long-running server's memory grew with every write made while other queries were running.
Durability
- Group commit groups. In
walmode concurrent commits now share one log write and one disk sync instead of syncing one after another, so write throughput scales with the number of concurrent writers. - Readers only see durable commits. In
walmode a commit becomes visible to other queries once it is on disk, so nothing a client read can be lost in a crash. - Saves don't stop the database. A save (
POST /api/save, the periodic checkpoint, shutdown) writes the file from a snapshot of one moment: queries and writes carry on while it runs, and the graph is no longer copied in memory first, so saving a large database needs no room for a second copy of it. Unloading or renaming a database holds writes, not reads, until its file is written. Two saves of the same database run one after the other, so an older one can never replace a newer file. Studio's in-browser engine exports the same way. - The log stays small. Every snapshot save (
POST /api/save, the periodic checkpoint, shutdown) deletes the redo-log segments it covers; previously they accumulated inwalmode. Snapshot files are installed with a durable rename, so a crash can't bring back the previous snapshot. - A closed database is one file. Closing a database, from an embedded binding or the CLI, deletes its redo log once the
.tvdbholds everything in it, so a file built with an SDK ortraverse-admincomes without a log segment beside it. - In
walmode a transaction larger than a log segment (32 MiB, e.g. one statement creating a few hundred thousand nodes) failed to commit. It now gets a log segment sized to hold it, and recovery replays it like any other. - Fixed: a database opened by a relative path (
open("registry.tvdb")) couldn't be opened again after a crash ("file exists"), since recovery looked for its redo log nowhere, and saving or closing it never removed the log. - Fixed: a database file opened without its redo log beside it (copied, uploaded or built on another machine) logged its new commits at positions the file already covered, so a crash lost them; the log now always continues past the file. A log left over from another copy of the database is no longer appended to.
- Fixed: a save running while writes were committing could record a commit as saved that wasn't in the file, so it was skipped on recovery; a commit landing during a save could be left out of the next save; the
wal-asyncbackground sync stalled commits while it ran.
Embedded bindings
- Closing a database is always safe. Closing (or disposing) a database rolls back the transactions and bulk writers still open on it, saves and releases the file; their later calls fail with a clear error instead of crashing the process. A transaction or bulk writer may also outlive its database object: the last handle to go saves and closes the file.
- Use from any thread. Transactions and bulk writers in .NET, Java, Go, Python and Node.js can be committed, aborted or queried from any thread, one call at a time, and one that is never closed is rolled back when the garbage collector finds it, releasing the writer lock.
- Read transactions.
BeginReadTransaction(.NET),beginRead(Java, Node.js),begin_read(Python),BeginRead(Go) andtraverse_begin_read(C) open a snapshot that runs alongside the writer and other readers. - Auto-commit queries.
Database.Query/QueryGql(.NET),execute(Java, Python, Node.js, withexecuteAsyncin Node.js),Execute/ExecuteGql/ExecuteContext(Go) andtraverse_execute/traverse_execute_gql(C) run a query as a transaction of its own: a read runs on a snapshot and never waits, a write commits when it succeeds and rolls back when it fails, andCALL { ... } IN TRANSACTIONScommits each batch. The query's plan decides read or write, procedures that write included. Cancel one with aCancellationToken, acontext.Context, anAbortSignalor a canceller fromtraverse_canceller_new; waiting for the writer lock stops too. - Plans are cached. Queries in the embedded bindings reuse plans across calls the way the server does: literals become parameters, so
{id: 7}and{id: 8}share a plan, and a new or dropped index replans. - Busy timeout. Waiting for the active write transaction is bounded: after 5 seconds by default,
begin, the bulk writer andflushfail with a busy error (TvErrorCode.Busy,traverse.BusyError,ErrBusy,TV_ERROR_BUSY) instead of waiting forever, so a secondbeginon the thread holding the writer no longer hangs. Change it withBusyTimeout(.NET),setBusyTimeout(Java),busy_timeout(Python),busyTimeout(Node.js),SetBusyTimeout(Go) ortraverse_set_busy_timeout(C). - Bulk writers are transactions. A bulk load is invisible to readers until it commits,
abortrolls it back, andcommitsaves the database with the load in it, so the data is written once and is durable whencommitreturns. Previously an aborted load stayed in memory and readers saw it while it was written. - Databases save themselves. An embedded database saves in the background once its redo log has grown by 64 MiB, or when a commit has gone five minutes unsaved, so the log stays short and reopening after a crash replays little, without the application calling
flush. A save that finds most of a file of 64 MiB or more reusable compacts it. - Saves don't hold up writes.
flushandcompactwork from a snapshot: the writer lock is held only for the moment it takes to start, so queries and commits carry on while the file is written, and what commits meanwhile is saved the next time. - Files stop growing under updates. A save reuses the space of the records it deletes or replaces, and finds a page with room through a map instead of reading every page of the file for each record, so saving a few changes to a large database stays quick and a database updated over and over keeps its size.
- Go modules live in the repository. The Go packages are now
github.com/truespar/traverse/go(embedded) andgithub.com/truespar/traverse/go/http(HTTP client), sogo getfetches them straight from GitHub; changetruespar.com/traverse-goimports to the new paths. The embedded package still loads the native library fromTRAVERSE_FFI_LIBor next to the binary. - Go on Linux and macOS. The embedded Go package only compiled on Windows; it now loads
libtraverse_ffi.so/.dylibwithdlopenthere too, still without CGo.Openreturns an error when the native library is missing or from another version, instead of panicking. - The native library as a download.
traverse-ffi-<version>-x86_64-windows.zipandtraverse-ffi-<version>-x86_64-linux.tar.gzon the GitHub release hold the library the Go package loads and C code links against, with its headertraverse.h. The header now declares the handle types as incomplete structs and wraps its declarations inextern "C", so it compiles as ISO C (-pedantic) and as C++, with GCC and MSVC. - Python releases the GIL while it waits for the writer lock, runs a query, commits, saves or closes, so other Python threads keep running.
- Node.js package. The embedded Node.js binding is published as
@truespar/traverse-node, with prebuilt addons for Windows x64 and Linux x64 (glibc) and TypeScript types. Results are built straight into JavaScript values, so floats keepNaNand+/-Infinity(they came back asnull), and a crash inside the engine fails the call with an error (GQLSTATUS50N42) instead of ending the Node.js process. - Bring your own native library.
TRAVERSE_FFI_LIB(.NET, as in Go) andTRAVERSE_JAVA_LIBor thetraverse.librarysystem property (Java) load the native library from a file, for a platform the packages don't bundle (macOS, ARM64) or a build of your own. - Java extracts its native library once. The jar's library now goes into a per-user cache (
%LOCALAPPDATA%\traverse\jnion Windows,~/Library/Caches/traverse/jnion macOS,~/.cache/traverse/jnion Linux), one copy per version, instead of a new temporary copy on every start, which Windows could never delete. - .NET reports a failed final save. Disposing a
Databasethrows aTraverseExceptionwhen the save it makes on closing fails, like aFileStreamwhose last flush fails, instead of dropping what changed since the last save without a word. - Fixed: on Linux the .NET, Java and Node.js embedded packages could fail to load their native library with "cannot allocate memory in static TLS block"; the Go bindings could report another call's error, or none, when a goroutine moved between threads; the Go bulk writer could pass the engine freed memory for a node's labels or the property keys and values of a node or relationship when a garbage collection ran at the wrong moment; Python raised
TraverseErrorinstead ofBusyErrorwhen a query's wait for the writer lock timed out; an embedded database opened without durability after a crash inwalmode replayed the recovered log tail again after every save; a full save (compact) left the redo-log segments it covered on disk.
Query engine
- Per-query memory budget. Every query now tracks the memory its own buffers hold - sorts, aggregations, hash joins,
Eagerbarriers, variable-length expansions, result sets - against a budget. A query that exceeds it fails with a clear error (query exceeded its memory limit ...) while the server and every other query keep running. Set with--query-memory-limit/TRAVERSE_QUERY_MEMORY_LIMIT/query_memory_limit(default 25% of system RAM,0= unlimited); shown asdb.memory.transaction.maxinSHOW SETTINGS. The process-level budget (TRAVERSE_MEMORY_LIMIT) is now also enforced inside query execution and applies by default to the CLI and the embedded bindings. - Streaming writes.
CREATE,SET,REMOVEandMERGEapply one row at a time instead of buffering their whole input and output, so imports (UNWIND $rows ... CREATE,LOAD CSV ... MERGE,MATCH (a {key}) MATCH (b {key}) CREATE (a)-[:R]->(b)) and statements withoutRETURNrun in memory proportional to a single row. The planner inserts anEageroperator - visible inEXPLAIN- only where a later clause must observe all of an earlier clause's writes. - Streaming joins and aggregation. Cartesian products and hash joins emit rows as they are produced rather than materializing the joined result;
count,sum,avg,min,maxandcollectover joins aggregate in one pass, holding only their groups. - Deep statements. Generated scripts with thousands of chained clauses or deeply nested expressions no longer abort the process; the engine sizes its stack to the statement and rejects pathological nesting with a clear error.
Seeing and stopping running work
SHOW TRANSACTIONSlists everything running, across sessions and protocols (Bolt, HTTP, WebSocket, gRPC, MCP, embedded), with the standard columns: database, transaction and query ids, connection, client address, user, current query, start time, status and elapsed time by default;YIELD *adds metadata (Bolttx_metadata), parameters, protocol, idle time and the memory the statement holds. Users see their own transactions; admins see everyone's.TERMINATE TRANSACTIONSstops them: by id, a list or a parameter, and chained afterSHOW TRANSACTIONS ... YIELD ... WHERE ...to stop whatever matches. The running statement stops within milliseconds, its writes are rolled back, and the transaction's next message fails withNeo.TransientError.Transaction.Terminated(gRPCABORTED).- A client going away stops its work: a Bolt
RESETor closed connection, an aborted or disconnected HTTP request, a cancelled gRPC call, and a new WebSocketcancelmessage. Studio's Run button turns into Stop while a query runs. - Time limits cover everything: the statement's whole run including parallel algorithm phases, nested
apoc.cypher.*calls and waiting for the writer lock. A Bolttx_timeoutnow limits the transaction fromBEGINand reportsNeo.ClientError.Transaction.TransactionTimedOutClientConfiguration; gRPC requests honortimeout_mswithDEADLINE_EXCEEDED. - No more stalls behind a heavy query: statements run off the server's async workers, so a long query on one connection can't hold up other connections or the cancels and timers above.
- Embedded bindings stop statements too. Each database has a statement timeout -
StatementTimeout(.NET),setStatementTimeout(Java),statement_timeout(Python),statementTimeout(Node.js),SetStatementTimeout(Go),traverse_set_statement_timeout(C) - and a running statement can be cancelled from another thread:Transaction.Cancelor aCancellationToken(.NET),cancel()(Java, Python, Node.js),Cancelor acontext.ContextwithExecuteContext(Go),traverse_canceller+traverse_cancel(C). Node.js getsexecuteAsync, which runs off the event loop and takes anAbortSignal. A stopped statement fails withTvErrorCode.Interrupted,QueryInterruptedException,traverse.QueryInterruptedError,ERR_TRAVERSE_INTERRUPTED,ErrInterruptedorTV_ERROR_INTERRUPTED. Embedded transactions are listed bySHOW TRANSACTIONS(protocolembedded, database = the file name) andTERMINATE TRANSACTIONSends them. - Fixed: parallel phases of graph algorithms (all-pairs shortest paths, betweenness, closeness, harmonic centrality, similarity, random walks, node2vec training) ignored the query's time limit;
apoc.cypher.runTimeboxedcleared the enclosing query's time limit and failed instead of returning the rows produced before its own limit (a timeboxed statement that writes still fails at its limit, so none of its writes are kept); APOC path expansion anddb.schema.*sampling returned partial results when stopped instead of an error; parallel workers could see a stale statement clock (datetime()from an earlier query) and Bolt results streamed after the server switched threads could lose their parameters; the MCP query tool crashed on a failed commit and didn't mark its writes for saving; the import endpoint could panic on statements with non-ASCII text in error reports.
GQL
WHENand transaction blocks run everywhere.WHEN <condition> THEN <statement> [ELSE <statement>]andSTART TRANSACTION [READ ONLY | READ WRITE] ... COMMITnow run on the server's GQL route and in every embedded binding; before, only the conformance test harness ran them. The condition is evaluated with no bindings (literals, parameters,SESSION_USER, functions). A transaction block runs its statements in order in the call's transaction, so over HTTP they all commit or none do, and returns the last statement's rows with every statement's counts;READ ONLYrefuses statements that write before any runs. A block ending inROLLBACKcan't contain writes: use an explicit transaction over Bolt, gRPC or the embedded API to discard work.- A GQLSTATUS for every error. Each error now names its condition with the ISO/IEC 39075 code where the standard has one (
22012division by zero,22003numeric overflow,22007invalid datetime format,25G03a write in aREAD ONLYblock,42001invalid syntax,G1001deleting a node that still has relationships) and Neo4j's published code otherwise (42N62variable not defined,42N48unknown function,42N08unknown procedure,42N51missing parameter,22N79/22N77/22N78uniqueness, existence and type constraints,25N17CALL { ... } IN TRANSACTIONSinside a transaction,51N73memory limit, ...). Bolt 5.7+ FAILURE carries it ingql_statusanddescriptionbeside the matching Neo4j code (division by zero is nowNeo.ClientError.Statement.ArithmeticError, an unknown procedureNeo.ClientError.Procedure.ProcedureNotFound, a busy writer lock the retryableNeo.TransientError.Transaction.LockAcquisitionTimeout); HTTP errors carrygql_statusin either dialect; gRPC errors carry agql-statusmetadata entry and a status code that follows it (NOT_FOUND,FAILED_PRECONDITION,RESOURCE_EXHAUSTED,UNAVAILABLE, ...); the embedded bindings expose it asTraverseException.GqlStatus(.NET),getGqlStatus()(Java),gql_status(Python),err.gqlStatus(Node.js),TraverseError.GqlStatus(Go) andtraverse_last_error_gql_status(C). - Multi-character and explicit trim.
btrim,ltrimandrtrimtake an optional second argument, the characters to strip (in Cypher too), and GQL hasTRIM([LEADING | TRAILING | BOTH] [char] FROM string). GQL trims strip spaces by default, as the standard says; Cypher keeps stripping any whitespace. USE <graph>switches graphs.USE social MATCH (n) RETURN nruns on the databasesocialover the HTTP API, whatever the request'sdatabasefield says;USE graph.byName($name)takes the name from a parameter. An embedded database runs aUSEthat names it and refuses any other graph. One request uses one graph: naming two is an error (25G04).CONFORMANCE.mdnow describes what the server and bindings run.- Fixed: a block ending in
ROLLBACKwas treated likeCOMMIT; a statement that only writes (INSERT ...withoutRETURN) couldn't be followed byCOMMIT,ROLLBACK,ELSE,ENDorNEXT.
Graph ML
- Node regression and link prediction pipelines next to node classification:
traverse.ml.pipeline.nodeRegression.*andtraverse.ml.pipeline.linkPrediction.*take the same configuration procedures,train,predict.streamandpredict.write. Link prediction scores the pairs that aren't connected yet and can write the top-ranked ones as new relationships. - R-GCN and GAT model candidates.
addRGcn(one weight matrix per relationship type) andaddGat(multi-head attention) joinaddGcnandaddGraphSagefor all three tasks. - Model selection the GDS way. Training holds out
testFractionof the examples, scores every candidate with (stratified) k-fold cross-validation overvalidationFolds, retrains the winner on the whole training set and reports train, validation, outer-train and test metrics inmodelInfo. Candidates accept ranges (addGcn('p', {hidden: {range: [16, 128]}, learningRate: {range: [0.001, 0.1]}})) sampled up tomaxTrials;configureAutoTuning('p', {strategy: 'successiveHalving'})spends the epoch budget on the most promising trials. Pick the selection metric withmetrics(ACCURACY,F1_WEIGHTED,F1_MACRO,MEAN_SQUARED_ERROR,ROOT_MEAN_SQUARED_ERROR,MEAN_ABSOLUTE_ERROR,AUCPR,ROC_AUC). - Node property steps.
addNodePropertyruns any node-property algorithm (PageRank, FastRP, Louvain, ...) or GraphMAE on the training graph before training and before every prediction, without writing to the database; select itsmutatePropertyas a feature. List and vector properties work as features too. - GraphMAE embeddings.
traverse.ml.graphMae.stream/.writelearn self-supervised node embeddings from node properties and the graph's structure. - Explanations.
traverse.ml.explain.pgExplainer,.counterfactualand.subgraphAuditname the relationships behind a node classification: the most important ones, the fewest whose removal changes the prediction, and a small reproducible subgraph that keeps it. predict.streamreturns class probabilities withincludePredictedProbabilities: trueand predicts the original class values; models predict on graphs that have grown since training;trainacceptsnodeLabels,relationshipTypes,targetNodeLabelsandwait: true;traverse.ml.trainStatusreports trial progress.- GPU training and inference. Servers built from source with the
ml-cudafeature train, predict, embed and explain on NVIDIA GPUs; the published binaries run ML on the CPU. Every ML call takes adevicesetting ('auto','cpu','gpu'or'gpu:<n>'); calls without one use--ml-device/TRAVERSE_ML_DEVICE/ml_device, by default the first usable GPU, else the CPU. The GPU driver is loaded at runtime, so the same binary runs on machines without one.traverse.ml.devices()lists the CPU and GPUs, and why a GPU can't be used when it can't. A model trained on one device predicts on any other. - Graphs of any size. When a full-graph training step wouldn't fit, training switches to mini-batches of sampled neighborhoods. Choose explicitly with
batching: 'fullGraph'or'miniBatch',batchSize(default 512) andfanouts(neighbors per hop, default[25, 10],-1for all). Sampled neighbors are weighted so training matches whole-graph prediction. Evaluation and prediction stay exact and run a block of nodes at a time, in bounded memory. GraphMAE trains in mini-batches too. - Training jobs queue. One training job runs at a time by default (
--ml-max-jobs/TRAVERSE_ML_MAX_JOBS/ml_max_jobs) and the rest wait their turn.traverse.ml.trainJobs()lists them andtraverse.ml.trainCancel(jobId)stops one.trainreturns at once: node property steps and GraphMAE now run inside the job. - Pipelines persist. Pipelines are saved next to the database files and reload at startup; trained models are saved atomically.
- Explanations scale. Explanations work on the explained nodes' exact computation subgraph, so they cost the same on any graph size. GraphMAE, predictions and explanations stop when the query times out or runs out of memory.
- Studio ML panel. Predict a number or missing relationships as well as a category; pick GCN, GraphSAGE, GAT or R-GCN, or compare them and keep the best. Choose the device and training mode. Follow trial progress, cancel a run, and see runs still in progress after a reload. Each task shows its own test scores. Suggest and write new relationships, explain a prediction and show it on the graph, and see predicted numbers as node sizes.
- Fixed: training saw only part of the relationships,
configureSplit,configureAutoTuningand node property steps had no effect, andpredict.writebypassed property indexes and the write-ahead log. Naming the classes of a model in Studio made it predict class positions instead of the class values. A model that couldn't be saved to disk was reported as trained without a warning;trainStatusnow says so inerror.
Vector indexes
- Updates and deletes keep the index healthy. Deleting a node or changing its embedding repairs the index in place and frees the slot for reuse, so search quality and memory stay steady under churn, with no rebuilds. Fixed: a query close to a deleted or updated vector could return no results.
Storage
- Database files are validated as they load. Every
.tvdbfile - uploaded to the server, imported in Studio, opened by the CLI or an embedded binding - is checked while it loads: page layout, record encoding, ids and counters, relationships, labels and property data. A damaged or deliberately crafted file is refused with a clear error instead of crashing the process or loading an inconsistent graph; files written by earlier releases load unchanged. - No size limit on a value. A node or relationship larger than a 16 KB page (a long text, a high-dimension embedding stored on a node, a large list or map) made every save of its database fail, so in the default snapshot mode the data written since the last save was lost at shutdown. Records, the schema catalog (names, index and constraint definitions, planner statistics) and the user catalog now continue on overflow pages when they need more than a page. A file that doesn't need them is written exactly as before, so earlier releases still open it; one that does says format version 7, which earlier releases refuse cleanly. In
walmode a single value larger than 16 MB now commits too. - Downloads are consistent. Adding or changing a user no longer rewrites a page of the database file in place: the new user catalog goes after the last page and the header switches to it. A database download that's running meanwhile gets the file as it was when the download started, never a mix of old and new pages.
- Checksummed
.tvmodelfiles and user catalog. Trained models and the user/role catalog are now stored in a framed container with a type tag, a format version and a CRC-32 checksum, so a truncated or corrupted file is reported as such instead of failing deep inside the parser - or loading with silently wrong contents. Files and databases written by earlier releases load unchanged and are rewritten in the new layout on their next save.
Users and databases
- User changes are saved as they're made.
CREATE USER,ALTER USERandDROP USERover Bolt and gRPC, and Studio's Users panel, write the change to the default database's file, crash-safely, before they return; a change that can't be saved fails and isn't made. Fixed: a periodic checkpoint orPOST /api/saveerased the users from the file, so the next start came up without them and with authentication off; with a data directory (--data <folder>) users were never loaded at startup, and Bolt and gRPC user changes weren't saved. - No silent open access. If the stored users can't be read, the server refuses to start instead of starting without authentication; start it with
--auth user:passto replace them with that admin. It also refuses to start when the default database's file can't be opened, instead of starting empty and saving over it. - Faster, fairer logins. gRPC checks a client's credentials once and remembers them until users change, instead of on every request. Password checks no longer hold up other logins or user changes, and an unknown user name takes as long to reject as a wrong password.
- Safer database management.
CREATE DATABASErefuses a name whose.tvdbfile is still in the data directory (an unloaded database, or one that failed to open) instead of overwriting it. The default database can't be unloaded, dropped or renamed. A file can be loaded as only one database at a time. Sessions still using a dropped or unloaded database get an error when they commit. - Fixed: renaming a database in
walorwal-asyncmode left its redo log under the old name, so commits since the last save were lost on restart; dropping a database left its redo log behind, where it could replay into a later database of the same name. Aliases and Studio's saved queries and styles are written crash-safely, and concurrent Studio edits no longer lose one another. - The Windows service is the full server. Running as a service now has gRPC, TLS, the periodic checkpoint,
wal-asyncsyncing, the configured durability mode, ML andSHOW SETTINGS, like the console server. - A request that panics no longer makes every later request touching the database list, users, query plans or background tasks fail. A background task that fails unexpectedly is reported as failed instead of staying "running" and blocking
/api/quiesce. Saves, loads, renames and user changes over HTTP no longer stall other requests while they write, and a download now fails if the database couldn't be saved first. - The Docker image has no built-in API key. It set
TRAVERSE_API_KEY=tvs_docker, a key anyone could look up; a container now generates its own at startup and prints it indocker logs. Pass-e TRAVERSE_API_KEY=tvs_...for a fixed one.
Fixes
- A query whose writes sat under
OPTIONAL MATCH,FOREACH, a relationship expansion or a few other operators could have them cut short:LIMITstopped early, and a Bolt client that discarded the rest of the results left them half applied. Such queries now always run every write. Procedures that write (apoc.create.*,apoc.merge.*,apoc.refactor.*,apoc.periodic.iterate, algorithm.writemodes, ...) count as writes the same way. PROFILEof a cached write skipped APOC triggers.=~and theapoc.text.*regex functions shared a cache of compiled patterns, so after one used a pattern the other could get the wrong form of it (apoc.text.split('a,b', ',')returned['a,b']after'a,b' =~ ','ran on the same thread).- Virtual nodes and relationships from trigger parameters (
$deletedNodes,$deletedRelationships) could share ids with ones made byapoc.create.vNode/vRelationshipin the same query. - Planner statistics too large for a file's catalog page (many labels and properties, collected with
ANALYZE GRAPH) pushed the constraint and index definitions saved after them out of place, so opening the file lost or misread them. The catalog now continues on further pages when it needs to, and every entry stays where it belongs. - A database whose latest commits came back from the redo log at startup counted as saved, so downloading it (or exporting it from Studio) before any other change returned a file without them, and the log segments holding them weren't trimmed.
- Embedded databases copied every node and relationship in memory on each save just to rewrite the file's catalog; a save now costs what changed since the last one.
- gRPC: a transaction begun read-only (
access_mode: "r", or on a read-only database) now rejects writes made throughRunand the node/relationship/index RPCs. - Algorithm write mode (
CALL traverse.pageRank.write(...),gds.<algo>.write) now updates property indexes on the written property and records the writes in the write-ahead log. - .NET Bolt driver: once the pool's background maintenance had evicted an idle connection,
BoltPoolcould open more connections thanMaxSize, and returning a connection could throwSemaphoreFullException. - .NET gRPC client:
TvValue.ToString()formatted numbers in the current culture (3,5in Swedish); it now uses the invariant culture.
Dependencies
- Removed the unmaintained
bincodeandrustls-pemfilecrates. TLS certificate and key loading now goes throughrustls-pki-types. - Studio:
monaco-editor0.56 withdompurify3.4.14, clearing every opennpm auditadvisory in the editor bundle;pinia4,markstream-vue2 (the Graph Assistant's markdown renderer). rusqlite0.40 (bundled SQLite 3.53) behindapoc.load.jdbc's SQLite dialect. A SQL string that contains more than one statement is now rejected with a clear error instead of silently running only the first.- Current major versions across the board:
ureq3 (the HTTP client behindLOAD CSV ... FROM 'http...',apoc.load.json/jsonParamsandapoc.spatial, which now stream response bodies instead of buffering them),arrow59,ed25519-dalek3,base640.23,lz4_flex0.14,comfy-table8. quick-xmlupdated to 0.41, which fixes two denial-of-service issues (quadratic duplicate-attribute checking and unbounded namespace-declaration allocation) reachable throughapoc.load.xml,apoc.import.xmland GraphML import.