All API Samples Best Practices cts CTS Query Geospatial GraphQL Indexes JavaScript JSON Llama Lessons MarkLogic MarkLogic 11 Optic API Performance Queries Search Security Semantics Starter Pack TDE Toolbox xdmp

JSON Root Elements and Document Structure

Understanding JSON Document Organisation in MarkLogic

JSON documents in MarkLogic do not have XML-style named root elements, which changes how structure, type identification, and query scoping work in production systems. This article explains the JSON node model, cts:document-root-query behaviour, path navigation, TDE context choices, and namespace-free subtree matching with scope queries. Use it as a practical guide to design predictable JSON document shapes and avoid silent structural query failures.

MarkLogicJSONDocument DesignLlama Lessons

All About Transactions

MVCC, Locks, XA, and Cross-Transaction Execution in MarkLogic

MarkLogic transactions control how query and update work happens across MVCC snapshots, locks, and commit boundaries. This article explains how query and update transactions behave, how XA and cross-transaction execution fit in, and where AMP handling changes practical outcomes. Use it as a production guide for diagnosing transaction visibility, avoiding lock surprises, and designing safer MarkLogic applications.

MarkLogicTransactionsACIDLlama Lessons

Near Queries and Proximity Search

Understanding How MarkLogic Measures Nearness

MarkLogic near queries let you search for terms that occur close together using index-based word-position distance. This article explains ordered and unordered proximity matching, fragment-boundary behaviour, property scoping, and practical performance patterns for production search. Use it to design near-query logic that stays accurate, interpretable, and fast on real MarkLogic datasets.

MarkLogicSearchQueriesLlama Lessons

Element Level Security

Working with TDE's

Template Driven Extraction (TDE) and Element Level Security (ELS) interact in ways that directly affect row visibility, document access, and security design in MarkLogic. Practical examples show the pitfalls and design implications for building secure TDE-backed applications.

TDESecurity

Filtered vs Unfiltered Searches

Understanding Search Behavior in MarkLogic

Filtered and unfiltered searches in MarkLogic trade query accuracy against speed, and the defaults vary by API and query shape. This guide explains when each mode applies, how path expressions change behavior, and when unfiltered results can be trusted.

MarkLogicSearchPerformanceLlama Lessons

JavaScript vs XQuery - When to Choose Which

Making the Right Language Choice

MarkLogic gives you both JavaScript and XQuery, and both are powerful, but they are not equally natural for every task. This guide gives practical, no-nonsense rules for choosing well across XML-heavy, JSON-heavy, and mixed workloads so your team ships faster with fewer avoidable mistakes.

MarkLogicJavaScriptXQueryLlama Lessons

Data Pipelines with n8n and MarkLogic

Part 1 - Data Ingestion

Build automated data pipelines with n8n and MarkLogic for JSON ingestion, workflow orchestration, and AI-ready data preparation. This first part focuses on ingestion patterns that support later work with LLMs, vector search, and RAG.

n8nMarkLogicingestion

Marklogic 11

Overview

This MarkLogic 11 review is based on more than 120 hours of testing across new features, bug fixes, and developer-facing changes. It covers the new UI, GraphQL, enhanced CTS and XDMP functions, Optic Update preview, and geospatial features with a practical assessment of real-world impact.

MarkLogic 11

Text Query Building Starter Pack

Compose text queries without turning your code into spaghetti

Master text search with cts:word-query(), cts:or-query(), and cts:not-query(). Tune stemming, wildcarding, case/diacritic sensitivity, and synonym behaviour with runnable examples on llamaverse data.

MarkLogicctsStarter PackAPI Samples

One Indexing Model for JSON and XML

Match Query Functions to the Right Index Across Both Document Models

JSON and XML queries in MarkLogic are conceptual twins: the same indexing decisions, the same range-query trade-offs, and the same failure modes when query type and index type do not match. This guide gives one unified decision framework, then shows the exact JSON and XML function variants side by side so you can move from idea to correct query pattern without guesswork.

MarkLogicIndexesJSON

Optic Data Analysis Starter Pack

Group, aggregate, reshape, and expand Optic result sets without losing the thread

Aggregate and group data with op:group-by(), op:array-aggregate(), op:group-to-arrays(), and op:group-by-union(). Build reporting shapes and ungrouping patterns with runnable llamaverse examples.

MarkLogicOptic APIStarter PackAPI Samples

Relevance and Scoring Starter Pack

Understand what ranked first and why

Understand MarkLogic relevance tuning with cts:score(), cts:confidence(), cts:fitness(), cts:remainder(), cts:quality(), and cts:relevance-info(). Learn why results rank in a specific order and how to inspect the signals behind that ranking.

MarkLogicctsStarter PackAPI Samples

URI and Collection Auditing Starter Pack

Reliable URI-level checks for real llamaverse operations

Audit document URIs and collections with cts:uris(), cts:collection-query(), and cts:collection-match(). Use wildcard discovery and collection scoping to validate document identity and organization in production systems.

MarkLogicctsStarter PackAPI Samples

URI Directory Queries in MarkLogic

How Slash Hierarchies Shape Query Scope

MarkLogic directory behaviour comes from URI structure, where each slash level defines queryable scope without requiring filesystem folders. This article explains how to use cts:directory-query depth correctly, avoid empty-result traps, and design URI hierarchies that support precise operational queries at scale. It also covers legacy WebDAV directory documents and safe, destructive-operation handling for directory deletion workflows.

MarkLogicDirectoriesDocument Management

MarkLogic Database Configuration Operator Manual

Every setting in the Admin Database Help page, explained with operational intent and testable behaviour

A full operator manual for MarkLogic database configuration. Covers every setting shown in the Admin UI, explains why each one exists, what breaks when it is wrong, and how to verify it — with runnable XQuery and JavaScript examples using llamaverse data.

MarkLogicDatabase AdministrationIndexingSearchOperations

Search Composition Starter Pack

Build and inspect practical query blocks on top of llamaverse content

Compose production-grade search with cts:search(), cts:and-query(), cts:contains(), cts:walk(), cts:highlight(), cts:parse(), and cts:estimate(). See how search text becomes nested and/or/near query trees, add lexicon-first scope with cts:uri-match() and cts:collection-match(), and validate behaviour with runnable llamaverse outputs.

MarkLogicctsStarter PackAPI Samples

Optic Data Source Starter Pack

Build Optic plans from views, lexicons, search, documents, and descriptors

Query diverse data sources with Optic functions like op.fromView(), op.fromSearch(), op.fromLexicons(), and op.fromSparql(). Build stable row plans from views, lexicons, search results, and more.

MarkLogicOptic APIStarter PackAPI Samples

Word Searches and the Optic API

Blend full-text search with structured row logic in one plan

Blend full-text search with Optic plans using cts:word-query(), op.fromSearch(), and op.where(). The examples show when to filter with a simple predicate and when to keep relevance scores visible for ranking.

MarkLogicOptic APIAPI Samples

Temporal Collections - Bitemporal vs Unitemporal

Understanding Time-Based Versioning

MarkLogic temporal collections support unitemporal and bitemporal models, and the difference directly affects auditability, compliance, and operational complexity. This article explains valid time versus system time, shows how axes and collections are configured, and highlights query patterns for each model. Use it as a production guide to choose the right temporal design early and avoid expensive migration later.

MarkLogicTemporalVersioningLlama Lessons

Optic Update

Released in MarkLogic 11

Optic Update in MarkLogic 11 extends the Optic API with JavaScript-based document mutation, including document descriptors, URI handling, locking, and temporal support. Code analysis and practical examples cover both simple and advanced update scenarios along with current preview limitations.

MarkLogic 11Optic API

All About Fragments

A Complete MarkLogic Guide to Fragment Behaviour

MarkLogic fragment roots and fragment parents shape XML indexing, search behaviour, hit scoping, and application-side result mapping. This guide explains how fragment boundaries affect real queries and how to configure them for reliable production search behaviour.

MarkLogicPerformanceIndexesLlama Lessons

Runtime and Storage Starter Pack

Fast checks for volume, placement, and document format in llamaverse

Use MarkLogic runtime and storage probes to answer practical operational questions about volume, placement, document format, and binary storage model - including the difference between regular and registered (external) binaries. These examples are useful when you need quick facts before tuning, debugging, or rebalancing content.

MarkLogicxdmpStarter PackAPI Samples

MarkLogic Security Model

Roles, Privileges, Permissions, and Amps

MarkLogic security works only when roles, privileges, document permissions, and amps are treated as separate control layers with different responsibilities. This article shows how those layers fit together in the real Llamaverse security model, where users, roles, URI privileges, and document permissions combine into an auditable access-control design. It also explains why execution-boundary functions such as eval and invoke need explicit amp-handling decisions instead of relying on inherited privilege state.

MarkLogicSecurityBest Practices

Path Namespaces - Query Configuration

Namespace Handling in Path Expressions

Namespace handling in MarkLogic path expressions controls whether XPath and path-range queries resolve element names correctly. This article explains how default namespaces, prefixed namespaces, and null namespaces affect matching behaviour, index usage, and query results in XML-heavy systems. Use it as a production guide to diagnose silent empty-result failures and configure namespace-aware queries reliably.

MarkLogicXPathNamespacesLlama Lessons

Document Inspection Starter Pack

Inspect document metadata by URI or straight from the node, run against llamaverse today

Inspect MarkLogic document metadata two ways: xdmp:document-xxx functions that need a URI, and xdmp:node-xxx functions that work directly on any node - however deep - and still resolve back to the owning fragment. Covers node-uri, node-kind, node-collections, node-permissions, document-get-collections, document-get-permissions, document-properties, document-get-metadata/document-set-metadata, node-metadata/node-metadata-value, and an inline cts:document-permission-query() demo for auditing permissions at scale.

MarkLogicxdmpStarter PackAPI Samples

The Importance of Traces

If You Are Not Tracing, You Are Troubleshooting Blind

MarkLogic traces are one of the most practical tools for production troubleshooting because they let code emit targeted diagnostics only when specific trace events are enabled. This guide explains `xdmp:trace()`, `xdmp:trace-enabled()`, and how to vary trace detail using current app-server log level so your logs stay useful instead of noisy. Use it to build trace output that tells a coherent troubleshooting story for the engineer who picks up the issue next.

MarkLogicTracingDebuggingBest Practices

Optic Data Manipulation Starter Pack

Shape XML, run expression libraries at runtime, and execute update plans cleanly

Transform row data with op:xpath(), op:write(), and op:execute(). Shape XML into rows, prove runtime expression evaluation with ofn/oxs/oxdmp, and drive privilege-snapshot update pipelines.

MarkLogicOptic APIStarter PackAPI Samples

GraphQL

Explicit schemas

Explicit GraphQL schemas in MarkLogic 11 let you model complex relationships with directives such as @View and @Join. Llamaverse examples show how to configure and query richer GraphQL schemas while accounting for current platform limits.

MarkLogic 11GraphQL

Migrating Server-Side JavaScript to MarkLogic 12

What Breaks, What Improves, and How to Upgrade Without Guesswork

MarkLogic 12 ships a much newer V8 engine, and your server-side JavaScript will feel the difference — some of it immediately, and some of it quietly, until a llama hits a fence post at speed. This guide covers what actually breaks, why it breaks, and how to fix it without turning a version bump into a month of surprises. Compatibility repairs first, then the genuinely useful new language features, then the grep commands to audit a whole codebase before anyone touches production.

MarkLogicJavaScriptUpgradeBest PracticesLlama Lessons

Llamaverse

Deploying and Using the Llamaverse 2.6.0 Dataset

Llamaverse 2.6.0 is the canonical sample dataset used across Clever Llamas MarkLogic articles, with deployment guidance, security roles, entity relationships, vector-ready content families, curated relevance quality profiles, geospatial region settings, and a llama-images content family (including one registered/external binary) required by temporal, namespace-aware path, lexicon-driven, reverse-geospatial, and storage-internals examples.

Toolbox

TDE Document Fragment

Using the document fragment in your views

Document fragments in MarkLogic TDE views affect runtime access patterns, join design, and view performance. This guide shows how to use fragment IDs and XPath lookups to enrich TDE-backed queries efficiently, especially on large datasets.

TDEToolboxOptic API

Triggers - Best Practices

Effective Trigger Implementation

MarkLogic triggers can enforce validation, launch post-commit side effects, and automate data workflows, but they sit directly on critical write paths. This article explains pre-commit versus post-commit trigger design, trigger security context, recursion avoidance, and why tracing is essential for reliable troubleshooting in production. Use it as a practical guide to building trigger patterns that remain observable, safe, and performant under real workload pressure.

MarkLogicTriggersBest PracticesLlama Lessons

Optic Geospatial

Released in MarkLogic 11

MarkLogic 11 Optic API geospatial features support spatial queries, movement tracking, and location analysis through TDE-backed data and SQL-style access. Practical examples cover implementation limits, performance trade-offs, and query design for geospatial workloads.

MarkLogic 11Optic APIGeospatial

GraphQL

Getting started

Get started with GraphQL in MarkLogic 11 by connecting built-in GraphQL support to existing schemas, views, and TDE templates. Llamaverse examples show implicit schemas, custom directives, range queries, sorting, and pagination.

MarkLogic 11GraphQL

Optic Update — JavaScript Implementation

Combining Row Pipelines with Document Mutation

Optic Update in MarkLogic 11 extends the Optic row pipeline into document mutation through patchBuilder, JavaScript APIs, and XQuery bridge patterns. This guide explains what is stable, what is preview, and the transaction and isolation habits required for safe production use.

MarkLogicOpticJavaScriptLlama Lessons

Geospatial Indexes — Point vs Region

Deep Dive on Geospatial Index Architecture in MarkLogic

MarkLogic geospatial search depends on choosing the right index type for points versus regions, with direct consequences for correctness, topology, and query design. This guide covers coordinate systems, rollout decisions, and production troubleshooting for geospatial workloads.

MarkLogicGeospatialIndexes

MarkLogic Community Event

July 2023

This recap of the July 2023 MarkLogic Community Event covers the Clever Llamas presentation on MarkLogic consulting, proof of values, health checks, and professional services. The recorded session shows how these services help teams build and sustain MarkLogic expertise.

News

Relevance Scoring - What Really Affects It

Understanding MarkLogic's Ranking Algorithm

MarkLogic relevance scoring determines result order using term frequency, inverse document frequency, query structure, and score options. This article explains why ties occur, how scoring behaves across common query patterns, and what changed between MarkLogic 11 and MarkLogic 12 defaults. Use it as a production guide to tune ranking with measurable evidence instead of guesswork.

MarkLogicSearchRelevanceLlama Lessons

All About Lexicons

URI, Collection, Value, Tuple and Optic Patterns in MarkLogic

MarkLogic lexicons let you answer URI, collection, and typed-value questions directly from indexes rather than scanning full documents. This guide shows practical MarkLogic 11+ patterns for `cts:uris`, `cts:values`, `cts:range-query`, `cts:tuples`, field references, and `op.fromLexicons`. Use it to build faster, safer query flows for faceting, filtering, co-occurrence analysis, and restartable operations.

MarkLogicLexiconsPerformanceLlama Lessons

Native Vector Search - AI-Powered Similarity at Scale

Practical Retrieval Design with Llamaverse 2.3.1

Most vector search implementations fail not because the model is wrong, but because the retrieval design is incomplete. This article shows how MarkLogic 12 lets you combine semantic similarity with permissions, metadata constraints, and lexical precision in a single query path — and uses the Llamaverse 2.3.1 vector lab to prove it with measured benchmarks, adversarial stress tests, and threshold analysis.

MarkLogic 12Vector SearchAIGenAIRetrieval Engineering

cts:document-root-query()

Released in MarkLogic 11

Find XML and JSON root elements with cts:document-root-query(). Learn how to filter documents by root-level structure, handle mixed-content repositories, and build root-scoped search patterns.

MarkLogic 11CTS Query

1 Day Challenge - Kendo UI and MarkLogic

Overview

This one-day Kendo UI and MarkLogic integration challenge explores what happens when MarkLogic backend capabilities meet Progress Kendo UI on the frontend. A video demonstration shows the practical result of building a working prototype in a single focused day.

MarkLogic 11Kendo UI

Document Permissions Query

Using cts:document-permission-query()

Learn how to use MarkLogic cts:document-permission-query() to find documents by read/update permissions, run scoped security audits, detect missing role permissions, and review live query examples with URI estimates and sample results.

MarkLogicSecurityCTS QueryLlama Lessons

Semantics and SPARQL Starter Pack

Parse RDF, load graph data, and query with SPARQL in one practical reference

A live-data MarkLogic Semantics and SPARQL reference using the llamaverse wild-llamas collection to demonstrate RDF parsing, named-graph insertion, in-memory and database-backed stores, external bindings, SELECT and CONSTRUCT queries, and graph lifecycle operations in XQuery and JavaScript.

MarkLogicSemanticsSPARQLStarter PackAPI Samples

Exploring op.select()

Project and shape columns before a plan gets harder to read than the data

Use op.select() to project and shape columns for clearer, more robust Optic output. The examples show how explicit selection keeps joined plans readable and avoids column-name conflicts.

MarkLogicOptic APIAPI Samples

Identity and Context Starter Pack

Who is actually running this, what they're allowed to do, and where it's happening

Twenty-two MarkLogic xdmp: functions that settle who is actually running this, what they're allowed to do, and where it's happening. Resolve users, roles, servers, and hosts with functions like xdmp:get-current-user(), xdmp:has-privilege(), and xdmp:role-get-default-permissions(), then check default permissions, external security, and login history - all with live-validated output in XQuery and JavaScript.

MarkLogicxdmpStarter PackAPI Samples

Optic Joins Starter Pack

Pick the right join shape before your plan becomes harder than the data

A live-data, tested guide to MarkLogic Optic joins using real llamaverse TDE rows. Compare inner, outer, existence, anti-existence, and cross-product joins, then explore op:join-inner equality keys, compound conditions, condition-only joins, and result-shape trade-offs in XQuery and JavaScript.

MarkLogicOptic APIStarter PackAPI Samples

Element Range Queries — Scalar Type Implications

Why Data Types Matter More Than You Think

Element range index scalar types in MarkLogic determine how values are indexed, compared, and returned by range queries. This article explains how type alignment affects correctness, index coverage, and production behaviour across strings, numbers, and date/time values. Use it as a practical guide to choose the right scalar type, avoid silent mismatches, and build predictable range-query designs.

MarkLogicIndexesData TypesLlama Lessons

Database and Environment Starter Pack

Database identity, forest topology, and deliberate cross-database execution

Fifteen MarkLogic xdmp: functions covering database identity lookups, forest topology, special-purpose system databases, App Server-to-database mapping, and cross-database execution with xdmp:eval(), xdmp:invoke(), and xdmp:spawn(). Everything you need to know exactly where a query is running, and to deliberately run it somewhere else.

MarkLogicxdmpStarter PackAPI Samples

Prototype TDE templates

Test SQL and Optic Against TDE Template Without Installing

Prototype MarkLogic TDE templates without installation or reindexing by combining tde:node-data-extract() with op:from-literals() and op:from-sparql(). This approach speeds up TDE development while preserving realistic datatype handling and query testing.

TDEToolboxOptic API

Triple Index and TDE Interaction

Understanding the Shared Foundation

MarkLogic stores both semantic triples and TDE rows on the triple index, and that shared foundation directly affects security, reindexing, and query behaviour. This guide explains the architecture, the `cts:column-range-query()` gotcha, and the practical design decisions teams need for reliable TDE workloads.

MarkLogicTDESemanticsLlama Lessons

Exploring op.fromLexicons()

Turn indexed lexicon values into join-friendly row plans

Use op.fromLexicons() to turn indexed lexicon values into join-friendly row plans. The article shows when lexicon-based access is a better fit than direct value extraction or document traversal.

MarkLogicOptic APIAPI Samples

cts:document-permission-query()

Released in MarkLogic 11

Query MarkLogic documents by permission status using cts:document-permission-query(). Learn how to build permission-aware search, audit security policies, and filter results by role or capability. Includes practical examples for access-control analysis.

MarkLogic 11CTS Query

Exploring op.fromView()

Turn TDE and relational views into stable row plans

Use op.fromView() to turn TDE and relational views into row plans ready for projection, joins, and analysis. The article shows how explicit qualifiers and column references keep plans maintainable as they grow.

MarkLogicOptic APIAPI Samples

Word Queries vs Value Queries

Choosing the Right Query Type

Word queries and value queries in MarkLogic may both accept strings, but they use different index behaviour and solve different search problems. This article explains when to use each query type, how token matching differs from exact value matching, and where range and lexicon-based queries fit in production designs. Use it as a practical guide to choose the right query pattern, avoid misleading results, and build more predictable search features.

MarkLogicSearchQueriesLlama Lessons