JSDoc: Global

Members

(constant) INCOMPLETE_PATTERNS

Patterns that indicate incomplete or missing information

Source:

compose/feedback/ResponseAnalyzer.js, line 17

(constant) NamespaceUtils

Utility Functions for Namespace Management

Source:

zpt/ontology/ZPTNamespaces.js, line 302

(constant) PromptTemplates

Export compatibility instances

Source:

prompts/compatibility.js, line 361

(constant) SPARQL_PREFIXES

Prefix map for SPARQL queries

Source:

zpt/ontology/ZPTNamespaces.js, line 575

(constant) UnifiedPromptSystem

Default export for convenience

Source:

prompts/index.js, line 213

(constant) ZPTQueryTemplates

Pre-built query templates for common operations

Source:

zpt/ontology/ZPTQueries.js, line 493

(constant) ZPTQueryUtils

Utility functions for query building

Source:

zpt/ontology/ZPTQueries.js, line 570

(constant) ZPTUtils

Utility functions for common operations

Source:

zpt/ontology/ZPTDataFactory.js, line 573

(constant) ZPT_STRING_MAPPINGS

String to URI mapping for ZPT navigation parameters

Source:

zpt/ontology/ZPTNamespaces.js, line 247

(constant) ZPT_URI_MAPPINGS

URI to string mapping for reverse lookups

Source:

zpt/ontology/ZPTNamespaces.js, line 278

(constant) beerqaTemplates

BeerQA SPARQL Templates - Domain-specific queries for BeerQA workflows

This file contains specialized SPARQL query templates for BeerQA operations including question augmentation, relationship building, and context retrieval.

BeerQA SPARQL Templates - Domain-specific queries for BeerQA workflows

This file contains specialized SPARQL query templates for BeerQA operations including question augmentation, relationship building, and context retrieval.

Source:

compose/sparql/templates/beerqa.js, line 8

(constant) feedbackTemplates

Feedback SPARQL Templates - Queries for iterative feedback workflows

This file contains SPARQL query templates specifically for the iterative feedback system including question generation, iteration tracking, and research progress monitoring.

Feedback SPARQL Templates - Queries for iterative feedback workflows

This file contains SPARQL query templates specifically for the iterative feedback system including question generation, iteration tracking, and research progress monitoring.

Source:

compose/sparql/templates/feedback.js, line 9

(constant) zptDataFactory

Default factory instance for convenience

Source:

zpt/ontology/ZPTDataFactory.js, line 568

Methods

_adjustEmbeddingLength(embedding, targetLength) → {Array.<number>}

Adjust embedding vector length to match target length

Parameters:

Name	Type	Description
`embedding`	Array.<number>	Source embedding vector
`targetLength`	number	Target length to match

Source:

stores/SPARQLStore.js, line 1679

Returns:

Adjusted embedding vector

Type: Array.<number>

_analyzeQuery()

Analyze query to determine search characteristics

Source:

api/features/UnifiedSearchAPI.js, line 493

_buildContext()

Build context for the LLM from conversation history and relevant memories

Source:

api/features/ChatAPI.js, line 322

_buildFilterClauses(filters) → {string}

Build SPARQL filter clauses from ZPT pan parameters

Parameters:

Name	Type	Description
`filters`	Object	Filter configuration (domains, keywords, temporal, etc.)

Source:

stores/SPARQLStore.js, line 893

Returns:

SPARQL filter clauses

Type: string

_calculateCosineSimilarity(vecA, vecB) → {number}

Calculate cosine similarity between two vectors

Parameters:

Name	Type	Description
`vecA`	Array.<number>	First vector
`vecB`	Array.<number>	Second vector

Source:

stores/SPARQLStore.js, line 1655

Returns:

Similarity score between 0 and 1

Type: number

_calculateFinalScore()

Calculate final score based on query analysis and result characteristics

Source:

api/features/UnifiedSearchAPI.js, line 441

(async) _callChat()

Call chat method using the appropriate provider interface

Source:

handlers/LLMHandler.js, line 38

(async) _callCompletion()

Call completion method using the appropriate provider interface

Source:

handlers/LLMHandler.js, line 53

_createConversation()

Create a new conversation

Source:

api/features/ChatAPI.js, line 306

(async) _createCorpusInterface()

Create a basic corpus interface for ZPT components

Source:

api/features/ZptAPI.js, line 553

(protected) _createResult()

Create standard workflow result object

Source:

compose/workflows/BaseWorkflow.js, line 58

_determineStrategy()

Determine optimal search strategy based on query analysis

Source:

api/features/UnifiedSearchAPI.js, line 525

(protected) _emitMetric()

Emit a metric event

Source:

api/common/BaseAPI.js, line 94

_escapeProperty(property) → {string}

Helper method to escape property names for SPARQL

Parameters:

Name	Type	Description
`property`	string	Property name to escape

Source:

stores/SPARQLStore.js, line 1993

Returns:

Escaped property name

Type: string

_escapeTripleQuotedString()

Escape text for use in SPARQL triple-quoted literals Triple-quoted literals can contain newlines and quotes but need backslashes escaped

Source:

stores/SPARQLStore.js, line 611

_estimateServiceRelevance()

Helper methods

Source:

api/features/UnifiedSearchAPI.js, line 665

_estimateTokens()

Estimate tokens for corpuscles (simple heuristic)

Source:

api/features/ZptAPI.js, line 572

(async) _executeArticleLookup()

Execute article lookup by title or page ID

Source:

api/features/WikipediaAPI.js, line 168

(async) _executeBatchSearch()

Execute batch search for multiple queries

Source:

api/features/WikipediaAPI.js, line 215

(async) _executeCategorySearch()

Execute category-based search

Source:

api/features/WikipediaAPI.js, line 433

(async) _executeConceptDiscovery()

Execute concept discovery from text

Source:

api/features/WikidataAPI.js, line 282

(async) _executeConceptResearch()

Execute Wikidata concept research

Source:

api/features/WikidataAPI.js, line 132

(async) _executeEntityLookup()

Execute entity lookup by ID or name

Source:

api/features/WikidataAPI.js, line 168

(async) _executeEntitySearch()

Execute entity search

Source:

api/features/WikidataAPI.js, line 218

(async) _executeIngest()

Execute article ingestion to knowledge graph

Source:

api/features/WikipediaAPI.js, line 324

(async) _executeNavigationFallback()

Fallback navigation implementation when NavigationEndpoint is not available

Source:

api/features/ZptAPI.js, line 492

(async) _executeParallelSearches()

Execute searches across all services in parallel

Source:

api/features/UnifiedSearchAPI.js, line 209

(async) _executeSPARQLQuery()

Execute SPARQL query against Wikidata

Source:

api/features/WikidataAPI.js, line 253

(async) _executeSPARQLQuery()

Execute SPARQL query

Source:

api/features/ZptAPI.js, line 1175

(async) _executeSPARQLUpdate()

Execute SPARQL update

Source:

api/features/ZptAPI.js, line 1189

(async) _executeSearch()

Execute Wikipedia search

Source:

api/features/WikipediaAPI.js, line 126

(async) _executeSequentialSearches()

Execute searches across services sequentially

Source:

api/features/UnifiedSearchAPI.js, line 261

(async) _executeServiceSearch()

Execute search on a specific service

Source:

api/features/UnifiedSearchAPI.js, line 315

(protected) _extractCommonResources()

Extract and validate common resources

Source:

compose/workflows/BaseWorkflow.js, line 122

_formatEntity()

Format entity for API response

Source:

api/features/RagnoAPI.js, line 715

_formatRDFObject()

Format RDF object for SPARQL

Source:

api/features/ZptAPI.js, line 1158

_formatRelationship()

Format relationship for API response

Source:

api/features/RagnoAPI.js, line 729

_formatSemanticUnit()

Format semantic unit for API response

Source:

api/features/RagnoAPI.js, line 702

_getConversation()

Get or create a conversation

Source:

api/features/ChatAPI.js, line 289

(protected) _getWorkflowMetadata()

Get workflow metadata for tracking

Source:

compose/workflows/BaseWorkflow.js, line 144

(protected) _handleError()

Handle errors with consistent format

Source:

compose/workflows/BaseWorkflow.js, line 97

(async) _initializeZPTComponents()

Initialize ZPT-specific components

Source:

api/features/ZptAPI.js, line 114

(protected) _logStep()

Log workflow step with consistent formatting

Source:

compose/workflows/BaseWorkflow.js, line 75

(protected) _measureTime()

Measure execution time for workflow steps

Source:

compose/workflows/BaseWorkflow.js, line 84

(protected) _mergeConfig()

Merge configuration with defaults

Source:

compose/workflows/BaseWorkflow.js, line 111

_normalizeResults()

Normalize results from different services to a common format

Source:

api/features/UnifiedSearchAPI.js, line 345

_parseJsonValue(jsonStr) → {any}

Parse JSON value safely, returning empty object/array on failure

Parameters:

Name	Type	Description
`jsonStr`	string	JSON string to parse

Source:

stores/SPARQLStore.js, line 1272

Returns:

Parsed value or default

Type: any

_parseQueryResults(result, zoomLevel) → {Array.<Object>}

Parse SPARQL query results into ZPT corpuscle format

Parameters:

Name	Type	Description
`result`	Object	SPARQL query result
`zoomLevel`	string	The zoom level for result interpretation

Source:

stores/SPARQLStore.js, line 949

Returns:

Parsed corpuscles

Type: Array.<Object>

_parseSPARQLResults()

Parse SPARQL results to simple objects

Source:

api/features/ZptAPI.js, line 1203

_rankAndMergeResults()

Rank and merge results from multiple services

Source:

api/features/UnifiedSearchAPI.js, line 410

_sanitizeParams()

Sanitize parameters for logging (remove sensitive data)

Source:

api/features/ZptAPI.js, line 590

(async) _searchEntities()

Search entities by name/type

Source:

api/features/RagnoAPI.js, line 743

(async) _searchSemantic()

Semantic search using embeddings

Source:

api/features/RagnoAPI.js, line 768

_selectServices()

Select services based on query analysis

Source:

api/features/UnifiedSearchAPI.js, line 545

(async) _serializeTriples()

Serialize triples to specified format

Source:

api/features/RagnoAPI.js, line 799

_simpleMergeResults()

Simple merge without ranking (fallback)

Source:

api/features/UnifiedSearchAPI.js, line 478

(async) _storeRDFInSPARQL()

Store RDF quads in SPARQL endpoint

Source:

api/features/ZptAPI.js, line 1128

_triplesToJSON()

Convert triples to JSON format

Source:

api/features/RagnoAPI.js, line 787

_updateAverage()

Update running average

Source:

api/features/ZptAPI.js, line 582

_validateFile()

Validate file upload

Source:

api/features/DocumentAPI.js, line 495

(protected) _validateInput()

Validate required input parameters

Source:

compose/workflows/BaseWorkflow.js, line 34

(protected) _validateParams()

Validate operation parameters

Source:

api/common/BaseAPI.js, line 83

_validateParams()

Validate operation parameters

Source:

api/features/DocumentAPI.js, line 512

_validateParams()

Validate required parameters

Source:

api/features/WikidataAPI.js, line 329

_validateParams()

Validate required parameters

Source:

api/features/WikipediaAPI.js, line 467

(protected) _validateResources()

Validate required resources

Source:

compose/workflows/BaseWorkflow.js, line 46

(async) adaptiveChunking()

Adaptive chunking strategy

Source:

zpt/transform/ContentChunker.js, line 332

addAltLabel(label, langopt)

Add SKOS alternative label

Parameters:

Name	Type	Attributes	Default	Description
`label`	string			Alternative label
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/models/RDFElement.js, line 144

addAlternativeName(altName, langopt)

Add an alternative label/name for this entity

Parameters:

Name	Type	Attributes	Default	Description
`altName`	string			Alternative name
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/Entity.js, line 189

addAttribute(content, subTypeopt)

Add an attribute to this entity

Parameters:

Name	Type	Attributes	Description
`content`	string		Attribute content
`subType`	string	<optional>	Attribute sub-type

Source:

ragno/Entity.js, line 258

addChunkOverlap()

Add overlap between consecutive chunks

Source:

zpt/transform/ContentChunker.js, line 783

addChunkRelationships()

Add relationships between chunks

Source:

zpt/transform/ContentChunker.js, line 850

addContent(subject, content)

Add content property to a resource

Parameters:

Name	Type	Description
`subject`	NamedNode	Resource
`content`	string	Text content

Source:

ragno/core/RDFGraphManager.js, line 91

addEntityConnection(entity, relevanceScoreopt)

Add a connection to an entity that this unit mentions

Parameters:

Name	Type	Attributes	Description
`entity`	Entity \| NamedNode \| string		Entity reference
`relevanceScore`	number	<optional>	Relevance score (0-1)

Source:

ragno/SemanticUnit.js, line 197

addEntityMention(entityURI, relevanceopt)

Add an entity mention to this semantic unit as an RDF triple

Parameters:

Name	Type	Attributes	Default	Description
`entityURI`	string			The URI of the mentioned entity
`relevance`	number	<optional>	1.0	Optional relevance/confidence score

Source:

ragno/SemanticUnit.js, line 309

addEvidence(evidence)

Add supporting evidence for this attribute

Parameters:

Name	Type	Description
`evidence`	SemanticUnit \| NamedNode \| string	Evidence source (e.g., semantic unit)

Source:

ragno/Attribute.js, line 222

addEvidence(evidence)

Add evidence or support for this relationship

Parameters:

Name	Type	Description
`evidence`	RDFElement \| NamedNode \| string	Evidence source (e.g., semantic unit)

Source:

ragno/Relationship.js, line 222

addHypothesisToRDF(hypothesisUnit, entities, relationships, targetDataset) → {number}

Add hypothesis and related data to RDF dataset with ragno:maybe property

Parameters:

Name	Type	Description
`hypothesisUnit`	SemanticUnit	Hypothesis semantic unit
`entities`	Array	Extracted entities
`relationships`	Array	Created relationships
`targetDataset`	Dataset	Target RDF dataset

Source:

ragno/algorithms/Hyde.js, line 452

Returns:

Number of triples added

Type: number

addInstructions()

Instruction and context enhancement

Source:

zpt/transform/PromptFormatter.js, line 833

addKeyword(keyword)

Add a keyword/tag to this attribute

Parameters:

Name	Type	Description
`keyword`	string	Keyword or tag

Source:

ragno/Attribute.js, line 258

addLabel(subject, label, langopt)

Add SKOS preferred label

Parameters:

Name	Type	Attributes	Default	Description
`subject`	NamedNode			Resource
`label`	string			Label text
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/core/RDFGraphManager.js, line 101

addNamespace(prefix, namespaceURI)

Add a custom namespace

Parameters:

Name	Type	Description
`prefix`	string	Namespace prefix
`namespaceURI`	string	Namespace URI

Source:

ragno/core/NamespaceManager.js, line 408

addNode(uri, embedding, metadata) → {number}

Add a node with its embedding to the index

Parameters:

Name	Type	Description
`uri`	string	Node URI
`embedding`	Array.<number>	Vector embedding
`metadata`	Object	Node metadata

Source:

ragno/search/VectorIndex.js, line 64

Returns:

Node ID in index

Type: number

addNodeToIndex(uri, embedding, metadataopt) → {number}

Add single node to vector index

Parameters:

Name	Type	Attributes	Description
`uri`	string		Node URI
`embedding`	Array		Vector embedding
`metadata`	Object	<optional>	Node metadata

Source:

ragno/search/index.js, line 252

Returns:

Node ID

Type: number

addNodesBatch(nodes) → {Array.<number>}

Add multiple nodes in batch

Parameters:

Name	Type	Description
`nodes`	Array	Array of {uri, embedding, metadata} objects

Source:

ragno/search/VectorIndex.js, line 114

Returns:

Array of node IDs

Type: Array.<number>

addNodesToIndex(nodes) → {Array}

Add nodes to vector index

Parameters:

Name	Type	Description
`nodes`	Array	Array of {uri, embedding, metadata} objects

Source:

ragno/search/index.js, line 235

Returns:

Array of node IDs added

Type: Array

addProvenance(sourceURI)

Add provenance information

Parameters:

Name	Type	Description
`sourceURI`	string	Source document/entity URI

Source:

ragno/models/RDFElement.js, line 214

addRelationshipTo(targetEntity, description, weightopt, relationshipTypeopt) → {Object}

Add a relationship to another entity

Parameters:

Name	Type	Attributes	Default	Description
`targetEntity`	Entity \| NamedNode \| string			Target entity
`description`	string			Relationship description
`weight`	number	<optional>	1.0	Relationship weight
`relationshipType`	string	<optional>		Type of relationship

Source:

ragno/Entity.js, line 210

Returns:

Relationship information

Type: Object

addSource(source)

Add a source document to this entity as an RDF triple

Parameters:

Name	Type	Description
`source`	string	The source document URI or string

Source:

ragno/Entity.js, line 287

addToContext()

Add interaction to context buffer with similarity score

Source:

ContextManager.js, line 41

addTooltip(selection, contentFunction) → {Object}

Add tooltip to a D3 selection

Parameters:

Name	Type	Description
`selection`	Object	D3 selection to add tooltip to
`contentFunction`	function	Function that returns tooltip content for a data item

Source:

frontend/js/utils/_d3-helpers.js, line 181

Returns:

The original selection for chaining

Type: Object

addTriple(subject, predicate, object, graphopt)

Add a triple to the dataset

Parameters:

Name	Type	Attributes	Description
`subject`	NamedNode		Subject node
`predicate`	NamedNode		Predicate node
`object`	NamedNode \| Literal		Object node or literal
`graph`	NamedNode	<optional>	Optional graph context

Source:

ragno/core/RDFGraphManager.js, line 70

addTriple(predicate, object, graphopt)

Add a triple to the dataset with this element as subject

Parameters:

Name	Type	Attributes	Description
`predicate`	NamedNode		Predicate
`object`	NamedNode \| Literal		Object
`graph`	NamedNode	<optional>	Optional graph context

Source:

ragno/models/RDFElement.js, line 73

addType(subject, type)

Add type declaration for a resource

Parameters:

Name	Type	Description
`subject`	NamedNode	Resource to type
`type`	NamedNode	RDF type (e.g., ragno:Entity)

Source:

ragno/core/RDFGraphManager.js, line 82

addType(type)

Add RDF type to this element

Parameters:

Name	Type	Description
`type`	NamedNode	RDF type

Source:

ragno/models/RDFElement.js, line 98

addUnitConnection(unit, relationTypeopt, weightopt)

Add a connection to another semantic unit

Parameters:

Name	Type	Attributes	Description
`unit`	SemanticUnit \| NamedNode \| string		Unit reference
`relationType`	string	<optional>	Type of relationship
`weight`	number	<optional>	Connection weight

Source:

ragno/SemanticUnit.js, line 229

addZoom(selection, options) → {Object}

Add zoom behavior to a D3 selection

Parameters:

Name	Type	Description
`selection`	Object	D3 selection
`options`	Object	Zoom options

Source:

frontend/js/utils/_d3-helpers.js, line 156

Returns:

Zoom behavior

Type: Object

adjustForTboxEnvironment()

Adjust configuration for tbox environment

Source:

Config.js, line 415

advancedEstimation(text, tokenizerName) → {Object}

Advanced token estimation with tokenizer-specific logic

Parameters:

Name	Type	Description
`text`	string	Text to estimate
`tokenizerName`	string	Tokenizer name

Source:

zpt/transform/TokenCounter.js, line 179

Returns:

Estimated token count

Type: Object

aggregateCommunities(graphData, llmHandler, optionsopt) → {Promise.<{communities: Array.<CommunityElement>, attributes: Array.<Attribute>, dataset: Dataset, statistics: Object}>}

Detect communities and generate comprehensive summaries using Leiden clustering

Parameters:

Name	Type	Attributes	Description
`graphData`	Object		Graph data with RDF dataset
`llmHandler`	Object		LLM handler instance
`options`	Object	<optional>	Community detection options

Source:

ragno/aggregateCommunities.js, line 150

Returns:

Type: Promise.<{communities: Array.<CommunityElement>, attributes: Array.<Attribute>, dataset: Dataset, statistics: Object}>

aggregationPhase(graph, nodeToCommId) → {Object}

Aggregation phase to create meta-graph

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`nodeToCommId`	Map	Current node to community mapping

Source:

ragno/algorithms/CommunityDetection.js, line 261

Returns:

Aggregated graph

Type: Object

(async) analyzeCompleteness(input, resources, options) → {Promise.<Object>}

Analyze response completeness and extract follow-up questions

Parameters:

Name Type Description

input

Object

Analysis input data

Properties

Name	Type	Description
`originalQuestion`	string	The original question asked
`response`	string	The response to analyze
`context`	string	Available context for the question

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for analysis

options

Object

Configuration options

Properties

Name	Type	Description
`completenessThreshold`	number	Threshold for completeness (default: 0.8)
`maxFollowUpQuestions`	number	Max follow-up questions to generate (default: 3)
`minConfidence`	number	Minimum confidence score (default: 0.7)

Source:

compose/feedback/ResponseAnalyzer.js, line 53

Returns:

Analysis results with completeness score and follow-up questions

Type: Promise.<Object>

analyzeConfidenceDistribution(entities) → {Object}

Analyze confidence distribution

Parameters:

Name	Type	Description
`entities`	Array	Array of entities with confidence scores

Source:

ragno/algorithms/VSOM.js, line 754

Returns:

Confidence analysis

Type: Object

analyzeContentType()

Analysis and insight extraction

Source:

zpt/transform/PromptFormatter.js, line 683

(async) analyzeNavigation()

Analyze navigation patterns and effectiveness

Source:

api/features/ZptAPI.js, line 943

(async) analyzeQuery()

Analyze query operation

Source:

api/features/UnifiedSearchAPI.js, line 567

analyzeTextStructure()

Analyze text structure for hierarchical chunking

Source:

zpt/transform/ContentChunker.js, line 669

applyContentAdjustments()

Apply content-type specific adjustments

Source:

zpt/transform/TokenCounter.js, line 259

(async) applyDeduplication()

Apply deduplication to remove similar results

Source:

ragno/search/SearchFilters.js, line 181

applyDiversityFilter()

Apply diversity filtering to reduce redundancy

Source:

zpt/selection/CorpuscleSelector.js, line 787

applyEntityFilter()

Apply entity-based domain filtering

Source:

zpt/selection/PanDomainFilter.js, line 240

applyEntityFilters(entities, filters) → {Array}

Apply filters to entity data

Parameters:

Name	Type	Description
`entities`	Array	Array of entities
`filters`	Object	Filter criteria

Source:

ragno/algorithms/VSOM.js, line 584

Returns:

Filtered entities

Type: Array

(async) applyFilters()

Main entry point for applying all filters to search results

Source:

ragno/search/SearchFilters.js, line 88

applyFilters(panParams, queryContext) → {Object}

Apply all pan filters to a selection query

Parameters:

Name	Type	Description
`panParams`	Object	Normalized pan parameters
`queryContext`	Object	Query context and constraints

Source:

zpt/selection/PanDomainFilter.js, line 157

Returns:

Enhanced query with domain filters

Type: Object

(async) applyFormatting()

Apply formatting to rendered content

Source:

prompts/PromptManager.js, line 222

applyGeographicFilter()

Apply geographic domain filtering

Source:

zpt/selection/PanDomainFilter.js, line 295

applyMemoryDomainFilter()

Memory domain filtering methods

Source:

zpt/selection/PanDomainFilter.js, line 619

(async) applyMemoryFilter()

Apply memory filter

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 561

applyPrivacyFilters()

Apply privacy filters to metadata

Source:

zpt/transform/MetadataEncoder.js, line 382

(async) applyRanking()

Apply ranking to results

Source:

ragno/search/SearchFilters.js, line 245

(async) applyRelevanceFiltering()

Apply relevance threshold filtering

Source:

ragno/search/SearchFilters.js, line 144

applyTemporalFilter()

Apply temporal domain filtering

Source:

zpt/selection/PanDomainFilter.js, line 267

applyTokenizerAdjustments()

Apply tokenizer-specific adjustments

Source:

zpt/transform/TokenCounter.js, line 228

applyTopicFilter()

Apply topic-based domain filtering

Source:

zpt/selection/PanDomainFilter.js, line 213

(async) applyTypeFiltering()

Apply document type filtering

Source:

ragno/search/SearchFilters.js, line 163

(async) attemptRecovery()

Attempt error recovery

Source:

zpt/api/ErrorHandler.js, line 338

augmentWithAttributes(graphData, llmHandler, optionsopt) → {Promise.<{attributes: Array.<Attribute>, dataset: Dataset, statistics: Object}>}

Augment entities with comprehensive attributes using graph analysis and LLM

Parameters:

Name	Type	Attributes	Description
`graphData`	Object		Decomposition results with RDF dataset
`llmHandler`	Object		LLM handler instance
`options`	Object	<optional>	Augmentation options

Source:

ragno/augmentWithAttributes.js, line 23

Returns:

Type: Promise.<{attributes: Array.<Attribute>, dataset: Dataset, statistics: Object}>

balanceChunkSizes()

Balance chunk sizes for more uniform distribution

Source:

zpt/transform/ContentChunker.js, line 758

(async) batchCountTokens(texts, tokenizer) → {Promise.<Array.<Object>>}

Count tokens for multiple texts in batch

Parameters:

Name	Type	Default	Description
`texts`	Array.<string>		Array of texts to count
`tokenizer`	string	null	Tokenizer name

Source:

zpt/transform/TokenCounter.js, line 330

Returns:

Array of token counts

Type: Promise.<Array.<Object>>

batchInsertData(graph, triplesBatch) → {string}

Batch multiple triples into a single INSERT DATA query

Parameters:

Name	Type	Description
`graph`	string	Named graph URI
`triplesBatch`	Array.<string>	Array of triple strings

Source:

services/sparql/SPARQLHelper.js, line 322

Returns:

Combined INSERT DATA query

Type: string

(async) batchResearch(questions, resources, options) → {Promise.<Array>}

Batch research multiple questions

Parameters:

Name	Type	Description
`questions`	Array.<string>	Questions to research
`resources`	Object	Required resources
`options`	Object	Research options

Source:

aux/ResearchService.js, line 261

Returns:

Array of research results

Type: Promise.<Array>

buildAggregationQuery()

Build aggregation query for community-level zoom

Source:

zpt/parameters/FilterBuilder.js, line 565

buildBatchConceptInsert()

Build SPARQL INSERT for batch concept creation

Source:

stores/RagnoMemoryStore.js, line 173

buildBatchFrequencyUpdate()

Build SPARQL UPDATE for batch frequency updates

Source:

stores/RagnoMemoryStore.js, line 206

buildBatchRelationshipUpdate()

Build SPARQL UPDATE for batch relationship updates

Source:

stores/RagnoMemoryStore.js, line 237

buildCacheKey()

Build cache key for query results

Source:

zpt/parameters/FilterBuilder.js, line 624

buildCommunities(nodeToCommId) → {Map}

Build communities map from node assignments

Parameters:

Name	Type	Description
`nodeToCommId`	Map	Node to community mapping

Source:

ragno/algorithms/CommunityDetection.js, line 399

Returns:

Community ID to nodes mapping

Type: Map

buildCompletenessFunction()

Build completeness scoring function

Source:

zpt/parameters/SelectionCriteria.js, line 454

buildConceptFilter()

Build concept filter clause

Source:

zpt/parameters/FilterBuilder.js, line 417

buildConceptFilters()

Build concept-specific filters for concept extraction queries

Source:

zpt/parameters/FilterBuilder.js, line 452

buildConceptQuery()

Build concept-based query using external templates

Source:

zpt/parameters/FilterBuilder.js, line 290

buildConnectivityFunction()

Build connectivity scoring function

Source:

zpt/parameters/SelectionCriteria.js, line 430

buildConstraints()

Build hard constraints

Source:

zpt/parameters/SelectionCriteria.js, line 187

buildContext()

Build complete context including history and current prompt

Source:

ContextManager.js, line 143

buildCriteria(normalizedParams) → {Object}

Build complete selection criteria from normalized parameters

Parameters:

Name	Type	Description
`normalizedParams`	Object	Normalized ZPT parameters

Source:

zpt/parameters/SelectionCriteria.js, line 61

Returns:

Selection criteria configuration

Type: Object

buildDiversityFunction()

Build diversity scoring function

Source:

zpt/parameters/SelectionCriteria.js, line 465

buildEntityDetailsQuery(entityUri) → {string}

Build SPARQL query for entity details

Parameters:

Name	Type	Description
`entityUri`	string	Entity URI

Source:

ragno/search/SearchAPI.js, line 514

Returns:

SPARQL query

Type: string

buildEntityExtractionPrompt(query) → {string}

Build entity extraction prompt for LLM

Parameters:

Name	Type	Description
`query`	string	User query

Source:

ragno/search/DualSearch.js, line 483

Returns:

Prompt for entity extraction

Type: string

buildEntityFilter()

Build entity filter clause

Source:

zpt/parameters/FilterBuilder.js, line 346

buildEntityRule()

Build entity-based selection rule

Source:

zpt/parameters/SelectionCriteria.js, line 350

buildExactMatchQuery(entities, types) → {string}

Build SPARQL query for exact matching

Parameters:

Name	Type	Description
`entities`	Array	Entity names to search for
`types`	Array	RDF types to include

Source:

ragno/search/DualSearch.js, line 524

Returns:

SPARQL query

Type: string

buildFilters()

Build filter clauses from pan parameters

Source:

zpt/parameters/FilterBuilder.js, line 256

buildFormattingContext()

Build comprehensive formatting context

Source:

zpt/transform/PromptFormatter.js, line 180

buildGeographicFilter()

Build geographic filter clause

Source:

zpt/parameters/FilterBuilder.js, line 381

buildGeographicRule()

Build geographic selection rule

Source:

zpt/parameters/SelectionCriteria.js, line 392

(async) buildGraphFromRDF(dataset, optionsopt) → {Object}

Build a graph from an RDF dataset (delegates to GraphAnalytics)

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF-Ext dataset
`options`	Object	<optional>	Graph construction options

Source:

ragno/algorithms/CommunityDetection.js, line 639

Returns:

Graph representation

Type: Object

buildGraphFromRDF(dataset, optionsopt) → {Object}

Build adjacency representation from RDF dataset

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF-Ext dataset
`options`	Object	<optional>	Graph construction options

Source:

ragno/algorithms/GraphAnalytics.js, line 43

Returns:

Graph representation with nodes and edges

Type: Object

buildGraphTraversalQuery(entityUris) → {string}

Build SPARQL query for graph traversal

Parameters:

Name	Type	Description
`entityUris`	Array	Starting entity URIs

Source:

ragno/search/DualSearch.js, line 590

Returns:

SPARQL query for building graph

Type: string

buildLimit()

Build LIMIT clause based on transform parameters

Source:

zpt/parameters/FilterBuilder.js, line 517

buildOptimizationRules()

Build optimization rules for performance

Source:

zpt/parameters/SelectionCriteria.js, line 294

buildOrderBy()

Build ORDER BY clause based on tilt representation

Source:

zpt/parameters/FilterBuilder.js, line 497

buildPrimaryRules()

Build primary selection rules (must-have criteria)

Source:

zpt/parameters/SelectionCriteria.js, line 86

buildQuery(normalizedParams) → {Object}

Build complete SPARQL query from normalized parameters

Parameters:

Name	Type	Description
`normalizedParams`	Object	Normalized ZPT parameters

Source:

zpt/parameters/FilterBuilder.js, line 221

Returns:

Query configuration

Type: Object

buildRecencyFunction()

Build recency scoring function

Source:

zpt/parameters/SelectionCriteria.js, line 442

buildRelevanceFunction()

Build relevance scoring function

Source:

zpt/parameters/SelectionCriteria.js, line 417

buildScoringRules()

Build scoring and ranking rules

Source:

zpt/parameters/SelectionCriteria.js, line 227

buildSecondaryRules()

Build secondary selection rules (preference-based)

Source:

zpt/parameters/SelectionCriteria.js, line 122

buildSelectClause(zoomLevel, tiltRepresentation) → {string}

Build zoom-specific SPARQL SELECT clause

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level
`tiltRepresentation`	string	The tilt representation

Source:

zpt/selection/ZoomLevelMapper.js, line 328

Returns:

SPARQL SELECT clause

Type: string

buildSelectionResult()

Build final selection result object

Source:

zpt/selection/CorpuscleSelector.js, line 850

buildSimilarityFilters()

Build similarity filters for concept matching

Source:

zpt/parameters/FilterBuilder.js, line 477

buildSimilarityQuery()

Build similarity search query for embedding-based tilt

Source:

zpt/parameters/FilterBuilder.js, line 532

buildTemporalFilter()

Build temporal filter clause

Source:

zpt/parameters/FilterBuilder.js, line 360

buildTemporalRule()

Build temporal selection rule

Source:

zpt/parameters/SelectionCriteria.js, line 364

buildTopicFilter()

Build topic filter clause

Source:

zpt/parameters/FilterBuilder.js, line 326

buildTopicRule()

Build topic-based selection rule

Source:

zpt/parameters/SelectionCriteria.js, line 335

buildTransformationContext()

Build comprehensive transformation context

Source:

zpt/transform/CorpuscleTransformer.js, line 233

buildTransitionMatrix(graph) → {Map}

Build transition matrix from graph adjacency

Parameters:

Name	Type	Description
`graph`	Object	Graph representation

Source:

ragno/algorithms/PersonalizedPageRank.js, line 209

Returns:

Transition probabilities

Type: Map

buildTypeFilter(zoomLevel, includePrimary, includeSecondary) → {string}

Build type filter clause for SPARQL queries

Parameters:

Name	Type	Default	Description
`zoomLevel`	string		The zoom level
`includePrimary`	boolean	true	Include primary types (default: true)
`includeSecondary`	boolean	false	Include secondary types (default: false)

Source:

zpt/selection/ZoomLevelMapper.js, line 165

Returns:

SPARQL type filter clause

Type: string

calculateAttributeConfidence(context, content, options) → {number}

Calculate confidence score for generated attribute

Parameters:

Name	Type	Description
`context`	Object	Entity context
`content`	string	Generated content
`options`	Object	Calculation options

Source:

ragno/augmentWithAttributes.js, line 496

Returns:

Confidence score 0-1

Type: number

calculateCacheHitRate() → {number}

Calculate cache hit rate

Source:

ragno/search/SearchAPI.js, line 602

Returns:

Cache hit rate percentage

Type: number

calculateCentroid()

Utility methods

Source:

zpt/selection/TiltProjector.js, line 867

calculateChunkSize()

Calculate chunk size based on strategy

Source:

zpt/parameters/ParameterNormalizer.js, line 273

calculateClusterCentroid(memberIndices) → {Array}

Calculate cluster centroid

Parameters:

Name	Type	Description
`memberIndices`	Array	Array of member node indices

Source:

ragno/algorithms/VSOM.js, line 699

Returns:

Centroid vector

Type: Array

calculateCommunityCohesion(community, graph) → {number}

Calculate cohesion score for a community

Parameters:

Name	Type	Description
`community`	Object	Community object
`graph`	Object	Graph object

Source:

ragno/aggregateCommunities.js, line 523

Returns:

Cohesion score 0-1

Type: number

calculateComplexity()

Calculate parameter complexity score

Source:

zpt/parameters/ParameterNormalizer.js, line 307

calculateConceptSimilarity()

Calculate semantic similarity between two concepts (simplified)

Source:

zpt/selection/PanDomainFilter.js, line 1151

calculateConfidence()

Quality calculation methods

Source:

zpt/transform/MetadataEncoder.js, line 598

calculateConfidence()

Calculate confidence in estimation

Source:

zpt/transform/TokenCounter.js, line 293

calculateContentSimilarity()

Calculate content similarity (simple Jaccard similarity)

Source:

ragno/search/SearchFilters.js, line 393

calculateContentSimilarity()

Calculate content similarity between corpuscles

Source:

zpt/selection/CorpuscleSelector.js, line 833

calculateCosineSimilarity()

Calculate cosine similarity between embeddings

Source:

zpt/selection/CorpuscleSelector.js, line 812

calculateDistance(vector1, vector2) → {number}

Calculate distance between two vectors

Parameters:

Name	Type	Description
`vector1`	Array	First vector
`vector2`	Array	Second vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 166

Returns:

Distance value

Type: number

calculateDistance(coords1, coords2) → {number}

Calculate distance between two nodes on the map

Parameters:

Name	Type	Description
`coords1`	Array	[x, y] coordinates of first node
`coords2`	Array	[x, y] coordinates of second node

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 47

Returns:

Distance between nodes

Type: number

calculateHexagonalDistance(coords1, coords2) → {number}

Calculate distance in hexagonal topology

Parameters:

Name	Type	Description
`coords1`	Array	[x, y] coordinates of first node
`coords2`	Array	[x, y] coordinates of second node

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 94

Returns:

Hexagonal distance

Type: number

calculateHybridScore()

Calculate hybrid score (type + score)

Source:

ragno/search/SearchFilters.js, line 472

calculateLearningRate(iteration) → {number}

Calculate learning rate for current iteration

Parameters:

Name	Type	Description
`iteration`	number	Current iteration

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 232

Returns:

Learning rate

Type: number

calculateMapDistance(coords1, coords2) → {number}

Calculate distance between two points on the map

Parameters:

Name	Type	Description
`coords1`	Array	[x, y] coordinates of first point
`coords2`	Array	[x, y] coordinates of second point

Source:

ragno/algorithms/vsom/VSOMCore.js, line 319

Returns:

Distance on the map

Type: number

calculateMemoryImportance(interaction, idx, currentTime) → {number}

Calculate multi-factor importance score for memory classification

Parameters:

Name	Type	Description
`interaction`	Object	The interaction to score
`idx`	number	Index in shortTermMemory array
`currentTime`	number	Current timestamp

Source:

stores/MemoryStore.js, line 106

Returns:

Importance score (0-10 scale)

Type: number

calculateModularity(graph, nodeToCommId) → {number}

Calculate modularity of current community structure

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`nodeToCommId`	Map	Community assignment

Source:

ragno/algorithms/CommunityDetection.js, line 357

Returns:

Modularity value

Type: number

calculateModularityGain(graph, node, fromComm, toComm, nodeToCommId) → {number}

Calculate modularity gain for moving a node between communities

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`node`	string	Node to move
`fromComm`	number	Source community
`toComm`	number	Target community
`nodeToCommId`	Map	Current community assignment

Source:

ragno/algorithms/CommunityDetection.js, line 328

Returns:

Modularity gain

Type: number

calculateNeighborhoodRadius(iteration) → {number}

Calculate neighborhood radius for current iteration

Parameters:

Name	Type	Description
`iteration`	number	Current iteration

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 263

Returns:

Neighborhood radius

Type: number

calculateNodeSimilarity(index1, index2) → {number}

Calculate similarity between two nodes

Parameters:

Name	Type	Description
`index1`	number	First node index
`index2`	number	Second node index

Source:

ragno/algorithms/VSOM.js, line 685

Returns:

Similarity score

Type: number

(async) calculateQualityMetrics(vsomCore, trainingData, iteration)

Calculate training quality metrics

Parameters:

Name	Type	Description
`vsomCore`	Object	VSOM core algorithm instance
`trainingData`	Array	Training data
`iteration`	number	Current iteration

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 311

calculateQuantizationError(inputData) → {number}

Calculate quantization error for the current map

Parameters:

Name	Type	Description
`inputData`	Array	Array of input vectors

Source:

ragno/algorithms/vsom/VSOMCore.js, line 348

Returns:

Average quantization error

Type: number

calculateQueryConfidence(queryData) → {number}

Calculate confidence score for query processing

Parameters:

Name	Type	Description
`queryData`	Object	Processed query data

Source:

ragno/search/DualSearch.js, line 749

Returns:

Confidence score 0-1

Type: number

calculateRectangularDistance(coords1, coords2) → {number}

Calculate distance in rectangular topology

Parameters:

Name	Type	Description
`coords1`	Array	[x, y] coordinates of first node
`coords2`	Array	[x, y] coordinates of second node

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 75

Returns:

Euclidean distance

Type: number

calculateRelationshipStrength()

Calculate relationship strength between two concepts

Source:

zpt/selection/TiltProjector.js, line 1027

calculateSemanticConnectivity(interaction, concepts) → {number}

Calculate semantic connectivity score based on concept overlap

Parameters:

Name	Type	Description
`interaction`	Object	Target interaction
`concepts`	Array	Interaction concepts

Source:

stores/MemoryStore.js, line 167

Returns:

Connectivity score (0-1)

Type: number

calculateSummaryConfidence(context, summary) → {number}

Calculate confidence for generated summary

Parameters:

Name	Type	Description
`context`	Object	Community context
`summary`	string	Generated summary

Source:

ragno/aggregateCommunities.js, line 492

Returns:

Confidence score 0-1

Type: number

calculateTopographicError(inputData) → {number}

Calculate topographic error for the current map

Parameters:

Name	Type	Description
`inputData`	Array	Array of input vectors

Source:

ragno/algorithms/vsom/VSOMCore.js, line 365

Returns:

Topographic error (0-1)

Type: number

calculateWeightedScore()

Calculate weighted score for a result

Source:

ragno/search/SearchFilters.js, line 463

canResolveFusekiHostname()

Check if we can resolve the 'fuseki' hostname (docker internal)

Source:

Config.js, line 403

checkAPIHealth()

Check API health

Source:

frontend/js/services/apiService.js, line 9

(async) checkContentSimilarity()

Check content similarity between results

Source:

ragno/search/SearchFilters.js, line 373

checkContextLimits(tokenCount, model, reservedOutputTokens) → {Object}

Check if content fits within model context limits

Parameters:

Name	Type	Default	Description
`tokenCount`	number		Token count to check
`model`	string		Model name
`reservedOutputTokens`	number	1000	Tokens to reserve for output

Source:

zpt/transform/TokenCounter.js, line 390

Returns:

Context limit check result

Type: Object

checkConvergence() → {boolean}

Check if training has converged

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 288

Returns:

True if converged

Type: boolean

(async) checkDependencyHealth()

Check if a dependency is healthy

Source:

zpt/api/NavigationEndpoint.js, line 804

checkRateLimit(req) → {boolean}

Check rate limiting for request

Parameters:

Name	Type	Description
`req`	Object	Express request object

Source:

ragno/search/SearchAPI.js, line 462

Returns:

True if request is allowed

Type: boolean

checkRateLimit()

Rate limiting

Source:

zpt/api/NavigationEndpoint.js, line 613

checkSystemHealth()

Utility to check system health

Source:

prompts/index.js, line 176

(async) chunk(markdown, metadata, options) → {Promise.<Object>}

Chunk markdown content with Ragno compliance

Parameters:

Name	Type	Description
`markdown`	string	Markdown content to chunk
`metadata`	Object	Source document metadata
`options`	Object	Chunking options

Source:

services/document/Chunker.js, line 41

Returns:

Chunking result with Ragno-compliant data structures

Type: Promise.<Object>

(async) chunk(content, options) → {Promise.<Object>}

Main chunking method - splits content based on strategy and constraints

Parameters:

Name	Type	Description
`content`	string \| Array	Content to chunk (string or array of corpuscles)
`options`	Object	Chunking options

Source:

zpt/transform/ContentChunker.js, line 113

Returns:

Chunking result

Type: Promise.<Object>

chunkCorpuscles()

Chunk corpuscles hierarchically

Source:

zpt/transform/ContentChunker.js, line 571

(async) chunkDocument()

Chunk document into semantic units

Source:

api/features/DocumentAPI.js, line 299

(async) chunkHierarchicalText()

Chunk hierarchical text based on structure

Source:

zpt/transform/ContentChunker.js, line 629

(async) chunkText()

Chunk text using the document Chunker

Source:

ragno/Memorise.js, line 409

classifyError()

Classify error type based on error properties

Source:

zpt/api/ErrorHandler.js, line 284

cleanHtml(html, options) → {string}

Clean HTML before conversion (remove scripts, styles, etc.)

Parameters:

Name	Type	Description
`html`	string	HTML content
`options`	Object	Cleaning options

Source:

services/document/HTMLConverter.js, line 259

Returns:

Cleaned HTML

Type: string

cleanSnippet(snippet) → {string}

Clean Wikipedia snippet text

Parameters:

Name	Type	Description
`snippet`	string	Raw snippet from Wikipedia

Source:

aux/wikipedia/Search.js, line 365

Returns:

Cleaned snippet text

Type: string

(async) cleanup()

Cleanup resources

Source:

ragno/Memorise.js, line 653

(async) cleanup()

Cleanup resources

Source:

ragno/search/SearchFilters.js, line 607

(async) cleanupPartialInitialization()

Cleanup partial initialization on failure

Source:

zpt/api/NavigationEndpoint.js, line 877

clear()

Clear the dataset

Source:

ragno/core/RDFGraphManager.js, line 289

clear()

Clear the entire index

Source:

ragno/search/VectorIndex.js, line 428

clearCache()

Clear template cache

Source:

aux/wikidata/QueryTemplateManager.js, line 302

clearCache()

Clear template cache

Source:

compose/sparql/TemplateManager.js, line 161

clearCache()

Clear response cache

Source:

ragno/search/SearchAPI.js, line 656

clearCache()

Reset and cleanup

Source:

zpt/transform/CorpuscleTransformer.js, line 901

clearCache()

Clear token cache

Source:

zpt/transform/TokenCounter.js, line 548

clearCaches()

Clear topology caches

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 371

(async) clearGraph(input, resources, options) → {Promise.<Object>}

Clear all triples from a named graph

Parameters:

Name Type Description

input

Object

Clear operation input data

Properties

Name	Type	Description
`graphURI`	string	URI of the graph to clear
`confirm`	boolean	Skip confirmation if true (default: false)

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations

options

Object

Configuration options

Properties

Name	Type	Description
`validateExists`	boolean	Check if graph exists before clearing (default: true)
`dryRun`	boolean	Only simulate the operation (default: false)

Source:

utils/GraphManager.js, line 26

Returns:

Operation results

Type: Promise.<Object>

clearStatistics()

Clear navigation statistics

Source:

aux/wikidata/WikidataNavigator.js, line 495

clearStatistics()

Clear statistics

Source:

aux/wikidata/WikidataResearcher.js, line 432

clearVectorIndex()

Clear vector index

Source:

ragno/search/index.js, line 481

clone(modificationsopt) → {Attribute}

Clone this attribute with optional modifications

Parameters:

Name	Type	Attributes	Description
`modifications`	Object	<optional>	Properties to modify in the clone

Source:

ragno/Attribute.js, line 480

Returns:

Cloned attribute

Type: Attribute

clone(modificationsopt) → {Entity}

Clone this entity with optional modifications

Parameters:

Name	Type	Attributes	Description
`modifications`	Object	<optional>	Properties to modify in the clone

Source:

ragno/Entity.js, line 433

Returns:

Cloned entity

Type: Entity

clone(modificationsopt) → {Relationship}

Clone this relationship with optional modifications

Parameters:

Name	Type	Attributes	Description
`modifications`	Object	<optional>	Properties to modify in the clone

Source:

ragno/Relationship.js, line 362

Returns:

Cloned relationship

Type: Relationship

clone(modificationsopt) → {SemanticUnit}

Clone this unit with optional modifications

Parameters:

Name	Type	Attributes	Description
`modifications`	Object	<optional>	Properties to modify in the clone

Source:

ragno/SemanticUnit.js, line 471

Returns:

Cloned unit

Type: SemanticUnit

clone() → {RDFGraphManager}

Clone the current dataset

Source:

ragno/core/RDFGraphManager.js, line 299

Returns:

New instance with cloned data

Type: RDFGraphManager

clone(optionsopt) → {RDFElement}

Clone this element with a new URI

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Options for the cloned element

Source:

ragno/models/RDFElement.js, line 560

Returns:

Cloned element

Type: RDFElement

(async) cluster(instanceId, options) → {Promise.<Object>}

Perform clustering on the trained SOM

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier
`options`	Object	Clustering options

Source:

services/vsom/VSOMService.js, line 326

Returns:

Clustering result

Type: Promise.<Object>

(async) clusterHypotheticalEntities(hypotheticalEntities) → {Promise.<Array>}

Cluster hypothetical entities separately

Parameters:

Name	Type	Description
`hypotheticalEntities`	Array	Array of hypothetical entities

Source:

ragno/algorithms/VSOM.js, line 743

Returns:

Hypothetical clusters

Type: Promise.<Array>

combineResults(resultsArray, optionsopt) → {Object}

Combine results from multiple PPR runs

Parameters:

Name	Type	Attributes	Description
`resultsArray`	Array		Array of PPR results
`options`	Object	<optional>	Combination options

Source:

ragno/algorithms/PersonalizedPageRank.js, line 412

Returns:

Combined results

Type: Object

combineSearchResults(searchResults, options) → {Object}

Combine and rank results from all search strategies

Parameters:

Name	Type	Description
`searchResults`	Object	Results from all search phases
`options`	Object	Ranking options

Source:

ragno/search/DualSearch.js, line 395

Returns:

Combined and ranked results

Type: Object

(async) combinedResearch(question, resources, options) → {Promise.<Object>}

Combined research using both Wikidata and Wikipedia

Parameters:

Name	Type	Description
`question`	string	Research question
`resources`	Object	Required resources (llmHandler, sparqlHelper, config)
`options`	Object	Research options

Source:

aux/ResearchService.js, line 122

Returns:

Combined research results

Type: Promise.<Object>

compileTrainingResults(trainingTime) → {Object}

Compile final training results

Parameters:

Name	Type	Description
`trainingTime`	number	Total training time

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 382

Returns:

Complete training results

Type: Object

compose(validators)

Create a composite validator from multiple validators

Parameters:

Name	Type	Description
`validators`	Array	Array of validator names or definitions

Source:

api/common/CustomValidators.js, line 144

compress(uri) → {string}

Create a prefixed name from full URI

Parameters:

Name	Type	Description
`uri`	string	Full URI

Source:

ragno/core/NamespaceManager.js, line 273

Returns:

Prefixed name or original URI if no prefix found

Type: string

compressMetadata()

Compress metadata based on compression level

Source:

zpt/transform/MetadataEncoder.js, line 341

computeBetweennessCentrality(graph, optionsopt) → {Object}

Compute betweenness centrality using Brandes' algorithm

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation from buildGraphFromRDF
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/GraphAnalytics.js, line 213

Returns:

Betweenness centrality results

Type: Object

computeCommunityStatistics(communities, graph) → {Object}

Compute statistics for detected communities

Parameters:

Name	Type	Description
`communities`	Map	Community mapping
`graph`	Object	Original graph

Source:

ragno/algorithms/CommunityDetection.js, line 513

Returns:

Community statistics

Type: Object

computeGraphStatistics(graph) → {Object}

Compute basic graph statistics

Parameters:

Name	Type	Description
`graph`	Object	Graph representation from buildGraphFromRDF

Source:

ragno/algorithms/GraphAnalytics.js, line 377

Returns:

Graph statistics

Type: Object

computeKCore(graph) → {Object}

Compute K-core decomposition K-core of a graph is the maximal subgraph where each vertex has at least k neighbors

Parameters:

Name	Type	Description
`graph`	Object	Graph representation from buildGraphFromRDF

Source:

ragno/algorithms/GraphAnalytics.js, line 135

Returns:

K-core decomposition results

Type: Object

computeLeidenClustering(graph, optionsopt) → {Object}

Compute Leiden clustering (alias for detectCommunities for pipeline compatibility)

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation from GraphAnalytics
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/CommunityDetection.js, line 51

Returns:

Community detection results

Type: Object

computeLeidenClustering(graph, optionsopt) → {Object}

Compute Leiden clustering (alias for detectCommunities for pipeline compatibility)

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation from GraphAnalytics
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/CommunityDetection.js, line 61

Returns:

Community detection results

Type: Object

(async) computeSimilarityLinks(embeddings, vectorIndex, options, dataset, rdfManager) → {Promise.<Object>}

Compute similarity links between nodes

Parameters:

Name	Type	Description
`embeddings`	Map	Map of embeddings
`vectorIndex`	Object	Vector index for similarity search
`options`	Object	Similarity options
`dataset`	Dataset	RDF dataset
`rdfManager`	RDFGraphManager	RDF manager

Source:

ragno/enrichWithEmbeddings.js, line 507

Returns:

Similarity statistics

Type: Promise.<Object>

conditional(condition, validator)

Create a conditional validator

Parameters:

Name	Type	Description
`condition`	function	Condition function
`validator`	string \| Object	Validator to apply if condition is true

Source:

api/common/CustomValidators.js, line 175

connectElements(source, target, weightopt)

Connect two elements with ragno:connectsTo

Parameters:

Name	Type	Attributes	Description
`source`	NamedNode		Source element
`target`	NamedNode		Target element
`weight`	number	<optional>	Optional connection weight

Source:

ragno/core/RDFGraphManager.js, line 197

connectTo(target, weightopt)

Connect this element to another element

Parameters:

Name	Type	Attributes	Description
`target`	RDFElement \| NamedNode		Target element
`weight`	number	<optional>	Optional weight

Source:

ragno/models/RDFElement.js, line 196

connects(entity1, entity2) → {boolean}

Check if this relationship connects two specific entities

Parameters:

Name	Type	Description
`entity1`	RDFElement \| NamedNode \| string	First entity
`entity2`	RDFElement \| NamedNode \| string	Second entity

Source:

ragno/Relationship.js, line 173

Returns:

True if relationship connects these entities

Type: boolean

(async) convert(filePath, options) → {Promise.<Object>}

Convert HTML file to markdown

Parameters:

Name	Type	Description
`filePath`	string	Path to HTML file
`options`	Object	Conversion options

Source:

services/document/HTMLConverter.js, line 17

Returns:

Conversion result with markdown and metadata

Type: Promise.<Object>

(async) convert(filePath, options) → {Promise.<Object>}

Convert PDF file to markdown

Parameters:

Name	Type	Description
`filePath`	string	Path to PDF file
`options`	Object	Conversion options

Source:

services/document/PDFConverter.js, line 17

Returns:

Conversion result with markdown and metadata

Type: Promise.<Object>

(async) convertBuffer(buffer, options) → {Promise.<Object>}

Convert PDF buffer to markdown

Parameters:

Name	Type	Description
`buffer`	Buffer	PDF file buffer
`options`	Object	Conversion options

Source:

services/document/PDFConverter.js, line 80

Returns:

Conversion result with markdown and metadata

Type: Promise.<Object>

(async) convertDocument()

Convert document to markdown

Source:

api/features/DocumentAPI.js, line 220

convertEntity(wikidataEntity, options) → {Object}

Convert Wikidata entity to Ragno format

Parameters:

Name	Type	Description
`wikidataEntity`	Object	Wikidata entity data
`options`	Object	Conversion options

Source:

aux/wikidata/WikidataToRagno.js, line 98

Returns:

Ragno entity with triples

Type: Object

convertParametersToZPTURIs()

Convert normalized parameters to ZPT URIs

Source:

zpt/selection/CorpuscleSelector.js, line 621

(async) convertParams()

Convert string-based navigation parameters to ZPT ontology URIs

Source:

api/features/ZptAPI.js, line 676

(async) convertString(html, options) → {Promise.<Object>}

Convert HTML string to markdown

Parameters:

Name	Type	Description
`html`	string	HTML string
`options`	Object	Conversion options

Source:

services/document/HTMLConverter.js, line 76

Returns:

Conversion result with markdown and metadata

Type: Promise.<Object>

convertToCSV(data) → {string}

Convert data to CSV format

Parameters:

Name	Type	Description
`data`	Array	Data to convert

Source:

ragno/algorithms/VSOM.js, line 791

Returns:

CSV string

Type: string

coordinatesToIndex(x, y) → {number}

Convert 2D map coordinates to linear index

Parameters:

Name	Type	Description
`x`	number	X coordinate
`y`	number	Y coordinate

Source:

ragno/algorithms/vsom/VSOMCore.js, line 309

Returns:

Linear index

Type: number

coordinatesToIndex(x, y) → {number}

Convert 2D coordinates to linear index

Parameters:

Name	Type	Description
`x`	number	X coordinate
`y`	number	Y coordinate

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 236

Returns:

Linear index

Type: number

cosineDistance(vector1, vector2) → {number}

Calculate cosine distance (1 - cosine similarity)

Parameters:

Name	Type	Description
`vector1`	Array	First vector
`vector2`	Array	Second vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 185

Returns:

Cosine distance

Type: number

countRules()

Count total number of rules

Source:

zpt/parameters/SelectionCriteria.js, line 503

(async) countTokens(text, tokenizer) → {Promise.<Object>}

Count tokens in text using specified tokenizer

Parameters:

Name	Type	Default	Description
`text`	string		Text to count tokens for
`tokenizer`	string	null	Tokenizer name (optional)

Source:

zpt/transform/TokenCounter.js, line 119

Returns:

Token count result

Type: Promise.<Object>

create(text, entity, optionsopt) → {Attribute}

Create an attribute with automatic URI generation

Parameters:

Name	Type	Attributes	Description
`text`	string		Attribute text content
`entity`	Entity \| NamedNode \| string		Associated entity
`options`	Object	<optional>	Additional options

Source:

ragno/Attribute.js, line 450

Returns:

Created attribute

Type: Attribute

create(name, optionsopt) → {Entity}

Create an entity with automatic URI generation

Parameters:

Name	Type	Attributes	Description
`name`	string		Entity name/label
`options`	Object	<optional>	Additional options

Source:

ragno/Entity.js, line 405

Returns:

Created entity

Type: Entity

create(sourceEntity, targetEntity, descriptionopt, optionsopt) → {Relationship}

Create a relationship between two entities with automatic naming

Parameters:

Name	Type	Attributes	Description
`sourceEntity`	RDFElement \| NamedNode \| string		Source entity
`targetEntity`	RDFElement \| NamedNode \| string		Target entity
`description`	string	<optional>	Relationship description
`options`	Object	<optional>	Additional options

Source:

ragno/Relationship.js, line 348

Returns:

Created relationship

Type: Relationship

create(text, optionsopt) → {SemanticUnit}

Create a semantic unit with automatic URI generation

Parameters:

Name	Type	Attributes	Description
`text`	string		Unit text content
`options`	Object	<optional>	Additional options

Source:

ragno/SemanticUnit.js, line 459

Returns:

Created unit

Type: SemanticUnit

(async) createAdaptiveChunk()

Create adaptive chunk from boundary group

Source:

zpt/transform/ContentChunker.js, line 549

createAttribute(entity, content, subTypeopt) → {NamedNode}

Create a ragno:Attribute with entity connection

Parameters:

Name	Type	Attributes	Description
`entity`	NamedNode		Entity this attribute describes
`content`	string		Attribute content
`subType`	string	<optional>	Attribute subtype (e.g., "Overview")

Source:

ragno/core/RDFGraphManager.js, line 173

Returns:

Created attribute node

Type: NamedNode

(async) createAttributeRelationships(attributes, dataset, rdfManager)

Create relationships between attributes for cross-referencing

Parameters:

Name	Type	Description
`attributes`	Array.<Attribute>	Generated attributes
`dataset`	Dataset	RDF dataset
`rdfManager`	RDFGraphManager	RDF manager

Source:

ragno/augmentWithAttributes.js, line 527

(async) createBackup()

Create backup of existing data

Source:

migration/DataMigration.js, line 98

createBatches(units, batchSize) → {Array}

Create batches from units array

Parameters:

Name	Type	Description
`units`	Array	Array of units
`batchSize`	number	Size of each batch

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 484

Returns:

Array of batches

Type: Array

createBidirectional(inverseDescriptionopt, inverseWeightopt) → {Relationship}

Create a bidirectional relationship (adds inverse)

Parameters:

Name	Type	Attributes	Description
`inverseDescription`	string	<optional>	Description for inverse relationship
`inverseWeight`	number	<optional>	Weight for inverse relationship

Source:

ragno/Relationship.js, line 143

Returns:

Inverse relationship

Type: Relationship

createCacheKey()

Caching methods

Source:

zpt/transform/CorpuscleTransformer.js, line 750

createCacheKey()

Cache management methods

Source:

zpt/transform/TokenCounter.js, line 471

createClearGraphQuery(graph) → {string}

Create CLEAR GRAPH query

Parameters:

Name	Type	Description
`graph`	string	Named graph URI to clear

Source:

services/sparql/SPARQLHelper.js, line 123

Returns:

SPARQL UPDATE query

Type: string

createColorScale(scheme, domain) → {function}

Create a color scale

Parameters:

Name	Type	Description
`scheme`	string	D3 color scheme name
`domain`	Array	Domain values

Source:

frontend/js/utils/_d3-helpers.js, line 115

Returns:

D3 color scale

Type: function

createCompactRepresentation()

Helper methods for encoding strategies

Source:

zpt/transform/MetadataEncoder.js, line 519

createCompatibilityMappings()

Create compatibility mappings for smooth transition

Source:

prompts/migrate-existing.js, line 194

createConnector(config) → {Object}

Create an embedding connector based on provider configuration

Parameters:

Name Type Description

config

Object

Provider configuration

Properties

Name	Type	Description
`provider`	string	Provider type ('ollama', 'nomic')
`model`	string	Model name to use
`options`	Object	Provider-specific options

Source:

connectors/EmbeddingConnectorFactory.js, line 17

Returns:

Embedding connector instance

Type: Object

(async) createCorpuscleForUnit(unit) → {Promise.<Object>}

Create corpuscle for a unit

Parameters:

Name	Type	Description
`unit`	Object	Unit data

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 354

Returns:

Corpuscle data with triples

Type: Promise.<Object>

createCrossReference(wikidataEntityURI, targetEntityURI, relationshipType, options) → {Object}

Create relationships between Wikidata and other entities

Parameters:

Name	Type	Default	Description
`wikidataEntityURI`	string		Wikidata entity URI
`targetEntityURI`	string		Target entity URI
`relationshipType`	string	related-to	Type of relationship
`options`	Object		Relationship options

Source:

aux/wikidata/WikidataToRagno.js, line 342

Returns:

Relationship triples

Type: Object

createDeleteInsertQuery(graph, deleteTriples, insertTriples, whereClause) → {string}

Create DELETE/INSERT query template

Parameters:

Name	Type	Description
`graph`	string	Named graph URI
`deleteTriples`	string	Triples to delete
`insertTriples`	string	Triples to insert
`whereClause`	string	WHERE clause conditions

Source:

services/sparql/SPARQLHelper.js, line 90

Returns:

SPARQL UPDATE query

Type: string

createDirectConceptFilter()

Concept filtering methods

Source:

zpt/selection/PanDomainFilter.js, line 1047

createDirectEntityFilter()

Entity filter implementations

Source:

zpt/selection/PanDomainFilter.js, line 382

createDropGraphQuery(graph) → {string}

Create DROP GRAPH query

Parameters:

Name	Type	Description
`graph`	string	Named graph URI to drop

Source:

services/sparql/SPARQLHelper.js, line 133

Returns:

SPARQL UPDATE query

Type: string

(async) createEmbeddingConnector()

Create embedding connector using configuration-driven factory pattern (from api-server.js)

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 75

(async) createEmbeddings()

Create embeddings for all chunks

Source:

ragno/Memorise.js, line 487

createEmptyResult(dataset, startTime) → {Object}

Create empty result for cases with no retrievable nodes

Parameters:

Name	Type	Description
`dataset`	Dataset	RDF dataset
`startTime`	number	Start time

Source:

ragno/enrichWithEmbeddings.js, line 664

Returns:

Empty result object

Type: Object

createEmptyResults() → {Object}

Create empty results structure

Source:

ragno/algorithms/PersonalizedPageRank.js, line 393

Returns:

Empty results

Type: Object

createEntity(name, isEntryPointopt) → {NamedNode}

Create a ragno:Entity with proper RDF structure

Parameters:

Name	Type	Attributes	Default	Description
`name`	string			Entity name
`isEntryPoint`	boolean	<optional>	true	Whether entity is an entry point

Source:

ragno/core/RDFGraphManager.js, line 111

Returns:

Created entity node

Type: NamedNode

createExactTemporalFilter()

Temporal filter implementations

Source:

zpt/selection/PanDomainFilter.js, line 461

createExactTopicFilter()

Topic filter implementations

Source:

zpt/selection/PanDomainFilter.js, line 322

createHypothesisPrompt(input, index, options) → {string}

Create a prompt for hypothesis generation

Parameters:

Name	Type	Description
`input`	string	Input query or entity URI
`index`	number	Hypothesis index for variation
`options`	Object	Options for prompt creation

Source:

ragno/algorithms/Hyde.js, line 246

Returns:

Generated prompt

Type: string

createHypothesisRelationships(originalInput, hypothesisUnit, entities) → {Array}

Create relationships between query, hypothesis, and extracted entities

Parameters:

Name	Type	Description
`originalInput`	string	Original input query
`hypothesisUnit`	SemanticUnit	Hypothesis semantic unit
`entities`	Array	Extracted entities

Source:

ragno/algorithms/Hyde.js, line 402

Returns:

Created relationships

Type: Array

createHypothesisUnit(hypothesis, originalInput, index) → {SemanticUnit}

Create a SemanticUnit for a hypothesis

Parameters:

Name	Type	Description
`hypothesis`	Object	Generated hypothesis object
`originalInput`	string	Original input query
`index`	number	Hypothesis index

Source:

ragno/algorithms/Hyde.js, line 323

Returns:

Hypothesis semantic unit

Type: SemanticUnit

createInsertDataQuery(graph, triples) → {string}

Create INSERT DATA query template

Parameters:

Name	Type	Description
`graph`	string	Named graph URI
`triples`	string	RDF triples in Turtle syntax

Source:

services/sparql/SPARQLHelper.js, line 33

Returns:

SPARQL UPDATE query

Type: string

createInsertQuery(graph, insertTriples, whereClause) → {string}

Create INSERT query template with WHERE clause

Parameters:

Name	Type	Description
`graph`	string	Named graph URI
`insertTriples`	string	Triples to insert
`whereClause`	string	WHERE clause conditions

Source:

services/sparql/SPARQLHelper.js, line 60

Returns:

SPARQL UPDATE query

Type: string

(async) createInstance(config) → {Promise.<Object>}

Create a new VSOM instance

Parameters:

Name	Type	Description
`config`	Object	Configuration for the VSOM instance

Source:

services/vsom/VSOMService.js, line 39

Returns:

Instance creation result

Type: Promise.<Object>

(async) createInterCommunityRelationships(communities, dataset, rdfManager, graph)

Create relationships between overlapping communities

Parameters:

Name	Type	Description
`communities`	Array.<CommunityElement>	Community elements
`dataset`	Dataset	RDF dataset
`rdfManager`	RDFGraphManager	RDF manager
`graph`	Object	Graph object

Source:

ragno/aggregateCommunities.js, line 551

createLegend(svg, colorScale, options) → {Object}

Create a legend for a color scale

Parameters:

Name	Type	Description
`svg`	Object	D3 SVG selection
`colorScale`	Object	D3 color scale
`options`	Object	Legend options

Source:

frontend/js/utils/_d3-helpers.js, line 205

Returns:

Legend object with update method

Type: Object

createLiteral(value, datatype, lang) → {string}

Create a safe literal value for SPARQL

Parameters:

Name	Type	Default	Description
`value`	string		Value to wrap
`datatype`	string	null	XSD datatype URI (optional)
`lang`	string	null	Language tag (optional)

Source:

services/sparql/SPARQLHelper.js, line 352

Returns:

SPARQL literal

Type: string

createNamedNode(type) → {NamedNode}

Create a new named node with generated URI

Parameters:

Name	Type	Description
`type`	string	Resource type

Source:

ragno/core/RDFGraphManager.js, line 58

Returns:

RDF named node

Type: NamedNode

createNamespace(baseURI) → {function}

Create namespace factory function

Parameters:

Name	Type	Description
`baseURI`	string	Base URI for the namespace

Source:

zpt/ontology/ZPTNamespaces.js, line 21

Returns:

Namespace factory function

Type: function

createNamespaceObject(baseURI) → {Proxy}

Create object proxy for namespace with property access

Parameters:

Name	Type	Description
`baseURI`	string	Base URI for the namespace

Source:

zpt/ontology/ZPTNamespaces.js, line 32

Returns:

Namespace proxy object

Type: Proxy

createNeighborhoodFunction(functionType) → {function}

Create neighborhood function for training

Parameters:

Name	Type	Default	Description
`functionType`	string	gaussian	'gaussian', 'mexican_hat', 'bubble', 'linear'

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 318

Returns:

Neighborhood function(distance, radius)

Type: function

createOverview(entity, text, optionsopt) → {Attribute}

Create an overview attribute for an entity (common pattern)

Parameters:

Name	Type	Attributes	Description
`entity`	Entity \| NamedNode \| string		Associated entity
`text`	string		Overview text
`options`	Object	<optional>	Additional options

Source:

ragno/Attribute.js, line 465

Returns:

Created overview attribute

Type: Attribute

createParameterHash()

Create a hash of normalized parameters for caching

Source:

zpt/parameters/ParameterNormalizer.js, line 334

createPointGeographicFilter()

Geographic filter implementations

Source:

zpt/selection/PanDomainFilter.js, line 534

createPromptContext()

Factory functions for easy creation

Source:

prompts/interfaces.js, line 508

createPromptManager()

Factory function for creating a configured prompt manager

Source:

prompts/index.js, line 98

(async) createRagnoStructure()

Create proper ragno structure with entities and relationships

Source:

migration/DataMigration.js, line 231

createRelationship(sourceEntity, targetEntity, description, weightopt) → {NamedNode}

Create a ragno:Relationship as first-class RDF resource

Parameters:

Name	Type	Attributes	Default	Description
`sourceEntity`	NamedNode			Source entity
`targetEntity`	NamedNode			Target entity
`description`	string			Relationship description
`weight`	number	<optional>	1.0	Relationship weight

Source:

ragno/core/RDFGraphManager.js, line 152

Returns:

Created relationship node

Type: NamedNode

createResponsiveSVG(container, options) → {Object}

Create a responsive SVG element

Parameters:

Name	Type	Description
`container`	HTMLElement	The container element
`options`	Object	Configuration options

Source:

frontend/js/utils/_d3-helpers.js, line 12

Returns:

D3 selection of the SVG element

Type: Object

(async) createSOMInstance()

Create a new SOM instance with specified configuration

Source:

api/features/VSOMAPI.js, line 126

createSemanticChunk()

Create semantic chunk object

Source:

zpt/transform/ContentChunker.js, line 531

(async) createTextUnit()

Create ragno:Unit and ragno:TextElement from input text

Source:

ragno/Memorise.js, line 355

createTooltip(options) → {Object}

Create a tooltip

Parameters:

Name	Type	Description
`options`	Object	Tooltip options

Source:

frontend/js/utils/_d3-helpers.js, line 51

Returns:

Tooltip functions

Type: Object

createURI(uri) → {string}

Create a safe URI for SPARQL

Parameters:

Name	Type	Description
`uri`	string	URI to wrap

Source:

services/sparql/SPARQLHelper.js, line 370

Returns:

SPARQL URI

Type: string

(async) createUnit(result, searchObject, index) → {Object}

Create RDF unit from Wikipedia search result

Parameters:

Name	Type	Description
`result`	Object	Wikipedia search result
`searchObject`	Object	Original search object
`index`	number	Result index

Source:

aux/wikipedia/Search.js, line 221

Returns:

RDF unit data

Type: Object

createUnit(content, sourceopt) → {NamedNode}

Create a ragno:Unit with proper RDF structure

Parameters:

Name	Type	Attributes	Description
`content`	string		Unit content
`source`	string	<optional>	Source document reference

Source:

ragno/core/RDFGraphManager.js, line 129

Returns:

Created unit node

Type: NamedNode

cubeToOffset(cube) → {Array}

Convert cube coordinates to offset coordinates

Parameters:

Name	Type	Description
`cube`	Object	Cube coordinates {x, y, z}

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 140

Returns:

Offset coordinates [col, row]

Type: Array

debounce(func, wait) → {function}

Debounce function

Parameters:

Name	Type	Description
`func`	function	Function to debounce
`wait`	number	Wait time in ms

Source:

frontend/js/utils/_d3-helpers.js, line 141

Returns:

Debounced function

Type: function

(async) decode()

Decoding methods for retrieving metadata

Source:

zpt/transform/MetadataEncoder.js, line 746

decomposeCorpus(textChunks, llmHandler, optionsopt) → {Promise.<{units: Array.<SemanticUnit>, entities: Array.<Entity>, relationships: Array.<Relationship>, dataset: Dataset}>}

Decompose text chunks into RDF-based semantic units, entities, and relationships

Parameters:

Name	Type	Attributes	Description
`textChunks`	Array.<{content: string, source: string}>		Text chunks to decompose
`llmHandler`	Object		LLM handler instance for executing prompts
`options`	Object	<optional>	Decomposition options

Source:

ragno/decomposeCorpus.js, line 18

Returns:

Type: Promise.<{units: Array.<SemanticUnit>, entities: Array.<Entity>, relationships: Array.<Relationship>, dataset: Dataset}>

(async) decomposeText()

Decompose text into knowledge graph entities and relationships

Source:

api/features/RagnoAPI.js, line 194

(async) decomposeText()

Decompose text into entities and relationships using ragno

Source:

ragno/Memorise.js, line 558

(async) deduplicateByContent()

Deduplicate by content similarity

Source:

ragno/search/SearchFilters.js, line 343

deduplicateByURI()

Deduplicate by URI

Source:

ragno/search/SearchFilters.js, line 322

(async) deduplicateHybrid()

Hybrid deduplication (URI + content)

Source:

ragno/search/SearchFilters.js, line 360

(async) deleteDocument()

Delete document and associated data

Source:

api/features/DocumentAPI.js, line 448

(async) deleteDocument(documentUri, options) → {Promise.<Object>}

Delete document and all related data

Parameters:

Name	Type	Description
`documentUri`	string	Document URI to delete
`options`	Object	Delete options

Source:

services/document/Ingester.js, line 446

Returns:

Delete result

Type: Promise.<Object>

(async) deleteInstance()

Delete a VSOM instance

Source:

api/features/VSOMAPI.js, line 408

(async) deleteInstance(instanceId) → {Promise.<Object>}

Delete a VSOM instance

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier

Source:

services/vsom/VSOMService.js, line 427

Returns:

Deletion result

Type: Promise.<Object>

detectCommunities(graph, optionsopt) → {Object}

Run Leiden algorithm for community detection

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation from GraphAnalytics
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/CommunityDetection.js, line 88

Returns:

Community detection results

Type: Object

detectTboxEnvironment()

Detect if running in tbox environment and adjust SPARQL configuration accordingly

Source:

Config.js, line 363

detectTopicDomain()

Domain detection methods

Source:

zpt/selection/PanDomainFilter.js, line 837

determineCorpuscleType()

Determine corpuscle type from SPARQL binding

Source:

zpt/selection/CorpuscleSelector.js, line 400

determineResponseType()

Determine response type based on data structure

Source:

zpt/api/ResponseFormatter.js, line 104

displayError(message, containeropt)

Display an error message in the specified container

Parameters:

Name	Type	Attributes	Description
`message`	string		The error message to display
`container`	HTMLElement	<optional>	Optional container to show the error in (defaults to document body)

Source:

frontend/js/utils/errorHandler.js, line 10

displayRecallResults()

Display recall results in the UI

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 569

(async) dispose()

Cleanup resources

Source:

api/features/DocumentAPI.js, line 521

dispose()

Clean up resources

Source:

stores/RagnoMemoryStore.js, line 342

dispose()

Dispose of resources

Source:

zpt/selection/CorpuscleSelector.js, line 948

(async) dropGraph(input, resources, options) → {Promise.<Object>}

Drop a named graph completely

Parameters:

Name Type Description

input

Object

Drop operation input data

Properties

Name	Type	Description
`graphURI`	string	URI of the graph to drop
`ifExists`	boolean	Only drop if exists (default: true)

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations

options

Object

Configuration options

Properties

Name	Type	Description
`dryRun`	boolean	Only simulate the operation (default: false)

Source:

utils/GraphManager.js, line 131

Returns:

Operation results

Type: Promise.<Object>

(async) dryRun(templateName, options) → {Promise.<Object>}

Dry run - execute query and show what would be ingested without calling tell

Parameters:

Name	Type	Description
`templateName`	string	Name of SPARQL template to use
`options`	Object	Options (same as ingestFromTemplate but no tellFunction)

Source:

services/ingestion/SPARQLDocumentIngester.js, line 353

Returns:

Preview of documents that would be ingested

Type: Promise.<Object>

(async) encode(formattedContent, fullContext, options) → {Object}

Main encoding method - embeds metadata into formatted content

Parameters:

Name	Type	Description
`formattedContent`	Object	Content from PromptFormatter
`fullContext`	Object	Complete processing context
`options`	Object	Encoding options

Source:

zpt/transform/MetadataEncoder.js, line 151

Returns:

Content with embedded metadata

Type: Object

(async) encodeStructured()

Encoding strategy implementations

Source:

zpt/transform/MetadataEncoder.js, line 418

enhanceClustersWithCentrality(graphResults) → {Array}

Enhance clusters with centrality measures

Parameters:

Name	Type	Description
`graphResults`	Object	Graph analytics results

Source:

ragno/algorithms/VSOM.js, line 780

Returns:

Enhanced clusters

Type: Array

(async) enhanceNavigation(input, resources, options) → {Promise.<Object>}

Enhance ZPT navigation with Wikidata integration

Parameters:

Name Type Description

input

Object

Navigation input data

Properties

Name	Type	Description
`question`	Object	Question object with text and uri
`localEntities`	Array.<Object>	Local entities from BeerQA navigation
`navigationContext`	Object	Existing navigation context

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for concept extraction
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs
`embeddingHandler`	Object	Embedding handler for similarity (optional)

options

Object

Configuration options

Properties

Name	Type	Description
`enableWikidataResearch`	boolean	Enable Wikidata research (default: true)
`maxWikidataEntities`	number	Max Wikidata entities (default: 10)
`createCrossReferences`	boolean	Create cross-references (default: true)
`similarityThreshold`	number	Similarity threshold for matching (default: 0.7)

Source:

aux/wikidata/WikidataNavigator.js, line 41

Returns:

Enhanced navigation results

Type: Promise.<Object>

enhanceSearchResults(pprResults, graph, dataset) → {Object}

Enhance search results with additional metadata

Parameters:

Name	Type	Description
`pprResults`	Object	PPR results
`graph`	Object	Graph representation
`dataset`	Dataset	Original RDF dataset

Source:

ragno/algorithms/index.js, line 205

Returns:

Enhanced results

Type: Object

(async) enrichGraph()

Enrich graph with embeddings and attributes

Source:

api/features/RagnoAPI.js, line 452

(async) enrichWithContext()

Enrich results with additional context

Source:

ragno/search/SearchFilters.js, line 210

enrichWithEmbeddings(graphData, embeddingHandler, optionsopt) → {Promise.<{vectorIndex: VectorIndex, embeddings: Map, similarityLinks: Array, dataset: Dataset, statistics: Object}>}

Enrich graph with vector embeddings and build searchable index

Parameters:

Name	Type	Attributes	Description
`graphData`	Object		Graph data with RDF dataset
`embeddingHandler`	Object		Semem's EmbeddingHandler instance
`options`	Object	<optional>	Enrichment options

Source:

ragno/enrichWithEmbeddings.js, line 22

Returns:

Type: Promise.<{vectorIndex: VectorIndex, embeddings: Map, similarityLinks: Array, dataset: Dataset, statistics: Object}>

(async) ensureInitialized() → {Promise.<void>}

Wait for the MemoryManager to be fully initialized

Source:

MemoryManager.js, line 97

Returns:

Type: Promise.<void>

ensureInitialized()

Ensure system is initialized

Source:

ragno/search/index.js, line 618

Throws:

If system is not initialized
Type Error

escapeString()

Helper methods

Source:

migration/DataMigration.js, line 396

escapeString(str) → {string}

Escape string literals for SPARQL

Parameters:

Name	Type	Description
`str`	string	String to escape

Source:

services/sparql/SPARQLHelper.js, line 333

Returns:

Escaped string safe for SPARQL

Type: string

escapeString()

Escape string for SPARQL

Source:

stores/RagnoMemoryStore.js, line 335

estimateConceptSelectivity()

Estimate selectivity for concept filters

Source:

zpt/selection/PanDomainFilter.js, line 1171

estimateConfidence(hypothesis, originalInput) → {number}

Estimate confidence score for a generated hypothesis

Parameters:

Name	Type	Description
`hypothesis`	string	Generated hypothesis text
`originalInput`	string	Original input query

Source:

ragno/algorithms/Hyde.js, line 268

Returns:

Confidence score between 0 and 1

Type: number

estimateCost(inputTokens, outputTokens, model) → {Object}

Estimate cost for token usage

Parameters:

Name	Type	Description
`inputTokens`	number	Number of input tokens
`outputTokens`	number	Number of output tokens
`model`	string	Model name

Source:

zpt/transform/TokenCounter.js, line 357

Returns:

Cost estimation

Type: Object

estimateMemoryUsage() → {number}

Estimate total memory usage

Source:

ragno/algorithms/VSOM.js, line 828

Returns:

Estimated memory usage in bytes

Type: number

estimateMemoryUsage() → {number}

Estimate memory usage of the algorithm

Source:

ragno/algorithms/vsom/VSOMCore.js, line 445

Returns:

Estimated memory usage in bytes

Type: number

estimateMemoryUsage() → {number}

Estimate memory usage of topology management

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 381

Returns:

Estimated memory usage in bytes

Type: number

estimateMemoryUsage() → {number}

Estimate memory usage

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 465

Returns:

Estimated memory usage in bytes

Type: number

estimateResults()

Estimate number of results based on complexity

Source:

zpt/parameters/FilterBuilder.js, line 612

estimateSegmentSize()

Estimate segment size between boundaries

Source:

zpt/transform/ContentChunker.js, line 508

estimateSelectivity()

Estimate selectivity of criteria

Source:

zpt/parameters/SelectionCriteria.js, line 477

estimateTokenCount()

Utility methods

Source:

zpt/transform/PromptFormatter.js, line 891

estimateTokenCount(text, tokenizerName) → {Object}

Simple token estimation fallback

Parameters:

Name	Type	Description
`text`	string	Text to estimate
`tokenizerName`	string	Tokenizer name

Source:

zpt/transform/TokenCounter.js, line 212

Returns:

Simple token estimate

Type: Object

estimateTokensPerResult(zoomLevel) → {number}

Estimate tokens per result for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 212

Returns:

Estimated tokens per result

Type: number

estimateTopicSelectivity()

Selectivity estimation methods

Source:

zpt/selection/PanDomainFilter.js, line 1009

euclideanDistance(vector1, vector2) → {number}

Calculate Euclidean distance

Parameters:

Name	Type	Description
`vector1`	Array	First vector
`vector2`	Array	Second vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 213

Returns:

Euclidean distance

Type: number

(async) execute(name, value, options)

Execute a validator

Parameters:

Name	Type	Description
`name`	string	Validator name
`value`	*	Value to validate
`options`	Object	Validator options

Source:

api/common/CustomValidators.js, line 119

(async) execute(input, resources, options) → {Promise.<Object>}

Execute the workflow - must be implemented by subclasses

Parameters:

Name	Type	Description
`input`	Object	Workflow input data
`resources`	Object	External dependencies
`options`	Object	Configuration options

Source:

compose/workflows/BaseWorkflow.js, line 26

Returns:

Workflow execution results

Type: Promise.<Object>

(async) execute(input, resources, options) → {Promise.<Object>}

Execute the standard BeerQA workflow

Parameters:

Name Type Description

input

Object

Workflow input data

Properties

Name Type Description

question

Object

Question object with text and optional uri

Properties

Name	Type	Description
`text`	string	The question text
`uri`	string	Question URI (optional)

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for answer generation
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object
`contextManager`	Object	Context manager for retrieval (optional)

options

Object

Configuration options

Properties

Name	Type	Description
`maxContextTokens`	number	Maximum context tokens (default: 4000)
`useEnhancedContext`	boolean	Use enhanced context retrieval (default: true)
`answerStyle`	string	Answer generation style (default: 'comprehensive')

Source:

compose/workflows/BeerQAWorkflow.js, line 39

Returns:

Workflow execution results with answer

Type: Promise.<Object>

(async) execute(input, resources, options) → {Promise.<Object>}

Execute the complete iterative feedback workflow

Parameters:

Name Type Description

input

Object

Workflow input data

Properties

Name	Type	Description
`question`	Object	Question object with text and optional uri
`enableIterativeFeedback`	boolean	Enable iterative feedback loops (default: true)
`enableWikidataResearch`	boolean	Enable Wikidata research (default: true)

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for analysis and generation
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object
`wikidataResearch`	Object	Wikidata research component (optional)

options

Object

Configuration options

Properties

Name	Type	Description
`maxIterations`	number	Maximum feedback iterations (default: 3)
`completenessThreshold`	number	Completeness threshold (default: 0.8)
`maxFollowUpQuestions`	number	Max follow-up questions per iteration (default: 2)
`workflowMode`	string	Workflow mode: 'fast', 'standard', 'comprehensive' (default: 'standard')

Source:

compose/workflows/FeedbackWorkflow.js, line 44

Returns:

Complete workflow results with iterative improvements

Type: Promise.<Object>

(async) execute(input, resources, options) → {Promise.<Object>}

Execute the Wikidata-enhanced BeerQA workflow

Parameters:

Name Type Description

input

Object

Workflow input data

Properties

Name	Type	Description
`question`	Object	Question object with text and optional uri
`enableWikidataResearch`	boolean	Enable Wikidata research (default: true)

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for answer generation
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object
`wikidataResearch`	Object	Wikidata research component (optional)

options

Object

Configuration options

Properties

Name	Type	Description
`maxWikidataEntities`	number	Max Wikidata entities to research (default: 15)
`fallbackToBeerQA`	boolean	Fallback to standard BeerQA if Wikidata fails (default: true)
`enhancementLevel`	string	Level of enhancement: 'basic', 'standard', 'comprehensive' (default: 'standard')

Source:

compose/workflows/WikidataWorkflow.js, line 43

Returns:

Workflow execution results with enhanced answer

Type: Promise.<Object>

(async) executeNavigationPipeline()

Execute complete navigation pipeline

Source:

zpt/api/NavigationEndpoint.js, line 521

(async, abstract) executeOperation(operation, params)

Execute a memory operation

Parameters:

Name	Type	Description
`operation`	string	Operation name
`params`	Object	Operation parameters

Source:

api/common/BaseAPI.js, line 44

(async) executeOperation()

Execute a chat operation

Source:

api/features/ChatAPI.js, line 40

(async) executeOperation()

Execute a document operation

Source:

api/features/DocumentAPI.js, line 63

(async) executeOperation()

Execute a memory operation

Source:

api/features/MemoryAPI.js, line 36

(async) executeOperation()

Execute a ragno operation

Source:

api/features/RagnoAPI.js, line 130

(async) executeOperation()

Execute a search operation

Source:

api/features/SearchAPI.js, line 45

(async) executeOperation()

Execute unified search operation

Source:

api/features/UnifiedSearchAPI.js, line 101

(async) executeOperation()

Execute a Wikidata operation

Source:

api/features/WikidataAPI.js, line 71

(async) executeOperation()

Execute a Wikipedia operation

Source:

api/features/WikipediaAPI.js, line 65

(async) executeOperation()

Execute a ZPT operation

Source:

api/features/ZptAPI.js, line 175

(async) executeQuery(sparql, options) → {Promise.<Object>}

Execute a SPARQL query against the Wikidata endpoint

Parameters:

Name	Type	Description
`sparql`	string	SPARQL query string
`options`	Object	Query-specific options

Source:

aux/wikidata/WikidataConnector.js, line 51

Returns:

Query results

Type: Promise.<Object>

(async) executeQuery()

Execute SPARQL query against the corpus

Source:

zpt/selection/CorpuscleSelector.js, line 353

(async) executeResearch(input, resources, options) → {Promise.<Object>}

Execute complete Wikidata research workflow

Parameters:

Name Type Description

input

Object

Research input data

Properties

Name	Type	Description
`question`	string	Research question or text to analyze
`concepts`	Array.<string>	Pre-extracted concepts (optional)

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for concept extraction
`sparqlHelper`	Object	SPARQL helper for storage operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Properties

Name	Type	Description
`maxEntitiesPerConcept`	number	Max entities per concept (default: 3)
`maxWikidataSearchResults`	number	Max search results (default: 15)
`minEntityConfidence`	number	Min confidence threshold (default: 0.4)
`enableHierarchySearch`	boolean	Enable hierarchy exploration (default: true)
`storeResults`	boolean	Store results in knowledge graph (default: true)

Source:

aux/wikidata/WikidataResearcher.js, line 45

Returns:

Research results with entities and metadata

Type: Promise.<Object>

(async) executeSPARQLQuery(endpoint, query, options) → {Promise.<Array>}

Execute SPARQL query (placeholder implementation)

Parameters:

Name	Type	Description
`endpoint`	string	SPARQL endpoint URL
`query`	string	SPARQL query
`options`	Object	Query options

Source:

ragno/algorithms/VSOM.js, line 554

Returns:

Query results

Type: Promise.<Array>

(async) executeSPARQLUpdate()

Execute SPARQL UPDATE operation

Source:

zpt/selection/CorpuscleSelector.js, line 707

(async) executeSelect(query) → {Promise.<Object>}

Execute SPARQL SELECT query

Parameters:

Name	Type	Description
`query`	string	SPARQL SELECT query

Source:

services/sparql/SPARQLHelper.js, line 216

Returns:

Response object with results

Type: Promise.<Object>

(async) executeSparqlQuery(query, variables) → {Promise.<Array>}

Execute SPARQL query against endpoint

Parameters:

Name	Type	Description
`query`	string	SPARQL query string
`variables`	Object	Variables to substitute in query

Source:

services/ingestion/SPARQLDocumentIngester.js, line 92

Returns:

Array of result bindings

Type: Promise.<Array>

(async) executeStageWithTimeout()

Pipeline execution utilities

Source:

zpt/transform/CorpuscleTransformer.js, line 690

(async) executeTemplate()

Execute a template with context and options

Source:

prompts/PromptManager.js, line 197

(async) executeUpdate(query) → {Promise.<Object>}

Execute SPARQL UPDATE query via HTTP POST

Parameters:

Name	Type	Description
`query`	string	SPARQL UPDATE query

Source:

services/sparql/SPARQLHelper.js, line 143

Returns:

Response object with success/error status

Type: Promise.<Object>

(async) executeUpdate()

Create test entities from existing TextElements for ZPT testing

Source:

zpt/_testing/CreateTestEntities.js, line 7

(async) executeUpdates(queries) → {Promise.<Array.<Object>>}

Execute multiple SPARQL UPDATE queries in sequence

Parameters:

Name	Type	Description
`queries`	Array.<string>	Array of SPARQL UPDATE queries

Source:

services/sparql/SPARQLHelper.js, line 292

Returns:

Array of response objects

Type: Promise.<Array.<Object>>

executeWithTimeout()

Utility methods

Source:

zpt/api/NavigationEndpoint.js, line 712

expandCluster(seedIndex, threshold, visited) → {Object}

Expand cluster using neighboring nodes

Parameters:

Name	Type	Description
`seedIndex`	number	Starting node index
`threshold`	number	Similarity threshold
`visited`	Set	Set of visited nodes

Source:

ragno/algorithms/VSOM.js, line 639

Returns:

Cluster object

Type: Object

(async) expandQueryTerms(entities) → {Array}

Expand query terms for enhanced matching

Parameters:

Name	Type	Description
`entities`	Array	Original entity terms

Source:

ragno/search/DualSearch.js, line 664

Returns:

Expanded terms

Type: Array

exportAllResultsToRDF(results, targetDataset)

Export all analysis results to RDF

Parameters:

Name	Type	Description
`results`	Object	Analysis results
`targetDataset`	Dataset	Target RDF dataset

Source:

ragno/algorithms/index.js, line 355

exportCommunitiesToRDF(results, targetDataset)

Export communities to RDF format

Parameters:

Name	Type	Description
`results`	Object	Community detection results
`targetDataset`	Dataset	Target RDF dataset

Source:

ragno/algorithms/CommunityDetection.js, line 569

exportEnrichmentResults(enrichmentResults, indexPath, optionsopt) → {Promise.<Object>}

Export enrichment results for use in search systems

Parameters:

Name	Type	Attributes	Description
`enrichmentResults`	Object		Results from enrichWithEmbeddings
`indexPath`	string		Path to save vector index
`options`	Object	<optional>	Export options

Source:

ragno/enrichWithEmbeddings.js, line 687

Returns:

Export statistics

Type: Promise.<Object>

(async) exportGraph()

Export graph data in specified format

Source:

api/features/RagnoAPI.js, line 398

exportResultsToRDF(results, targetDataset, graphUriopt)

Export analysis results to RDF format

Parameters:

Name	Type	Attributes	Description
`results`	Object		Analysis results
`targetDataset`	Dataset		Target RDF dataset
`graphUri`	string	<optional>	Optional graph context URI

Source:

ragno/algorithms/GraphAnalytics.js, line 447

exportResultsToRDF(results, targetDataset)

Export PPR results to RDF format

Parameters:

Name	Type	Description
`results`	Object	PPR results
`targetDataset`	Dataset	Target RDF dataset

Source:

ragno/algorithms/PersonalizedPageRank.js, line 467

exportToDataset(targetDataset)

Export all triples of this element to a target dataset

Parameters:

Name	Type	Description
`targetDataset`	Dataset	The RDF-Ext dataset to export to

Source:

ragno/models/RDFElement.js, line 579

exportToRDF(dataset, optionsopt) → {number}

Export results to RDF dataset

Parameters:

Name	Type	Attributes	Description
`dataset`	Object		RDF dataset to augment
`options`	Object	<optional>	Export options

Source:

ragno/algorithms/VSOM.js, line 353

Returns:

Number of triples added

Type: number

exportVisualization(formatopt) → {Object|string}

Export visualization coordinates

Parameters:

Name	Type	Attributes	Default	Description
`format`	string	<optional>	coordinates	Output format ('coordinates', 'json', 'csv')

Source:

ragno/algorithms/VSOM.js, line 436

Returns:

Visualization data

Type: Object | string

(async) extractAndResearchConcepts(text, resources, options) → {Promise.<Object>}

Extract concepts from text and optionally research them

Parameters:

Name	Type	Description
`text`	string	Text to analyze
`resources`	Object	Required resources (llmHandler)
`options`	Object	Processing options

Source:

aux/ResearchService.js, line 211

Returns:

Concept extraction and research results

Type: Promise.<Object>

extractBasicInfo()

Extract basic request information

Source:

zpt/api/RequestParser.js, line 83

extractClientInfo()

Extract client information

Source:

zpt/api/RequestParser.js, line 426

extractClientIp()

Extract real client IP address

Source:

zpt/api/RequestParser.js, line 448

extractCommunityKeywords(summary, memberEntities) → {Array.<string>}

Extract keywords from community summary and members

Parameters:

Name	Type	Description
`summary`	string	Generated summary
`memberEntities`	Array	Community member entities

Source:

ragno/aggregateCommunities.js, line 450

Returns:

Extracted keywords

Type: Array.<string>

(async) extractConcepts()

Extract concepts from text

Source:

api/features/MemoryAPI.js, line 213

(async) extractConcepts(text) → {Promise.<Array.<string>>}

Parameters:

Name	Type	Description
`text`	string

Source:

handlers/LLMHandler.js, line 158

Returns:

Type: Promise.<Array.<string>>

(async) extractConcepts()

Extract concepts from specific chunks

Source:

ragno/Memorise.js, line 523

extractContent()

Extract content from SPARQL binding

Source:

zpt/selection/CorpuscleSelector.js, line 422

extractContentString()

Helper methods for pipeline stages

Source:

zpt/transform/CorpuscleTransformer.js, line 560

extractCorpuscleConcepts()

Extract concepts from a corpuscle

Source:

zpt/selection/PanDomainFilter.js, line 1119

extractEntitiesFromDataset(dataset) → {Array}

Extract entities from RDF dataset (helper method)

Parameters:

Name	Type	Description
`dataset`	Dataset	RDF dataset

Source:

ragno/algorithms/index.js, line 479

Returns:

Array of entities

Type: Array

(async) extractEntitiesFromHypothesis(hypothesis, llmHandler, options) → {Array}

Extract entities from a generated hypothesis

Parameters:

Name	Type	Description
`hypothesis`	Object	Generated hypothesis object
`llmHandler`	Object	LLM handler instance
`options`	Object	Extraction options

Source:

ragno/algorithms/Hyde.js, line 349

Returns:

Extracted entities

Type: Array

(async) extractEntitiesFromUnit()

Extract entities from unit content using simple keyword extraction

Source:

migration/DataMigration.js, line 261

extractEntityData(entity) → {Object}

Extract entity data from various entity formats

Parameters:

Name	Type	Description
`entity`	Object	Entity object

Source:

ragno/algorithms/VSOM.js, line 515

Returns:

Extracted entity data

Type: Object

extractKeywords(content) → {Array.<string>}

Extract keywords from attribute content

Parameters:

Name	Type	Description
`content`	string	Attribute content

Source:

ragno/augmentWithAttributes.js, line 456

Returns:

Extracted keywords

Type: Array.<string>

extractKeywords()

Analysis and processing methods

Source:

zpt/selection/TiltProjector.js, line 503

extractLimit()

Extract LIMIT value from query string

Source:

zpt/parameters/FilterBuilder.js, line 604

extractMetadata()

Extract metadata from SPARQL binding

Source:

zpt/selection/CorpuscleSelector.js, line 437

extractMetadata()

Extract comprehensive metadata from processing context

Source:

zpt/transform/MetadataEncoder.js, line 205

extractNamespace()

Extract namespace from topic string

Source:

zpt/parameters/ParameterNormalizer.js, line 290

extractNavigationMetadata()

Extract navigation-specific metadata

Source:

zpt/transform/MetadataEncoder.js, line 231

extractPerformanceMetadata()

Extract performance metadata

Source:

zpt/transform/MetadataEncoder.js, line 272

(async) extractProvenanceContext()

Extract provenance context for a result

Source:

ragno/search/SearchFilters.js, line 565

extractProvenanceMetadata()

Extract data provenance metadata

Source:

zpt/transform/MetadataEncoder.js, line 252

extractQualityMetadata()

Extract quality indicators

Source:

zpt/transform/MetadataEncoder.js, line 301

(async) extractRelationshipContext()

Extract relationship context for a result

Source:

ragno/search/SearchFilters.js, line 538

extractScore()

Extract score from result object

Source:

ragno/search/SearchFilters.js, line 315

(async) extractSourceContext()

Extract source context for a result

Source:

ragno/search/SearchFilters.js, line 551

extractSubgraph(graph, nodes) → {Object}

Extract subgraph containing only specified nodes

Parameters:

Name	Type	Description
`graph`	Object	Original graph
`nodes`	Set	Nodes to include

Source:

ragno/algorithms/CommunityDetection.js, line 438

Returns:

Subgraph

Type: Object

extractTechnicalMetadata()

Extract technical implementation details

Source:

zpt/transform/MetadataEncoder.js, line 317

extractTextContent()

Helper methods for content extraction

Source:

zpt/selection/TiltProjector.js, line 437

extractTextContent()

Extract text content from corpuscle for concept extraction

Source:

zpt/selection/TiltProjector.js, line 1004

fetchWithTimeout(resource, options, timeout) → {Promise.<Response>}

Fetch with timeout utility

Parameters:

Name	Type	Description
`resource`	string	URL to fetch
`options`	object	Fetch options
`timeout`	number	Timeout in milliseconds (default: 30000)

Source:

frontend/js/utils/_api.js, line 17

Returns:

Type: Promise.<Response>

filterCorpuscles()

Apply selection criteria to filter corpuscles

Source:

zpt/selection/CorpuscleSelector.js, line 546

filterSmallCommunities(communities, minSize) → {Map}

Filter out communities smaller than minimum size

Parameters:

Name	Type	Description
`communities`	Map	Community mapping
`minSize`	number	Minimum community size

Source:

ragno/algorithms/CommunityDetection.js, line 418

Returns:

Filtered communities

Type: Map

findBestMatchingUnits(inputBatch) → {Array}

Find Best Matching Units (BMUs) for a batch of input vectors

Parameters:

Name	Type	Description
`inputBatch`	Array	Array of input vectors

Source:

ragno/algorithms/vsom/VSOMCore.js, line 126

Returns:

Array of BMU indices for each input

Type: Array

findConnectedComponents(subgraph) → {Array}

Find connected components in a subgraph

Parameters:

Name	Type	Description
`subgraph`	Object	Subgraph to analyze

Source:

ragno/algorithms/CommunityDetection.js, line 469

Returns:

Array of connected components

Type: Array

findConnectedComponents(graph) → {Object}

Find connected components using DFS

Parameters:

Name	Type	Description
`graph`	Object	Graph representation from buildGraphFromRDF

Source:

ragno/algorithms/GraphAnalytics.js, line 312

Returns:

Connected components information

Type: Object

findCrossTypeNodes(graph, topNodes) → {Array}

Find nodes that connect different types (bridge nodes)

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`topNodes`	Array	Top-ranked nodes to analyze

Source:

ragno/algorithms/PersonalizedPageRank.js, line 359

Returns:

Cross-type bridge nodes

Type: Array

(async) findEntitiesByLabel(labels, options) → {Promise.<Object>}

Find entities by label (text search)

Parameters:

Name	Type	Description
`labels`	string \| Array.<string>	Label(s) to search for
`options`	Object	Search options

Source:

aux/wikidata/WikidataConnector.js, line 228

Returns:

Search results

Type: Promise.<Object>

(async) findEntitiesByWikipediaTitle(titles, options) → {Promise.<Object>}

Find entities by Wikipedia article title

Parameters:

Name	Type	Description
`titles`	string \| Array.<string>	Wikipedia article title(s)
`options`	Object	Search options

Source:

aux/wikidata/WikidataConnector.js, line 287

Returns:

Matching entities

Type: Promise.<Object>

findEntityCluster(entityIndex, clusters) → {number}

Find which cluster an entity belongs to

Parameters:

Name	Type	Description
`entityIndex`	number	Entity index
`clusters`	Array	Array of clusters

Source:

ragno/algorithms/VSOM.js, line 722

Returns:

Cluster index or -1 if not found

Type: number

(async) findLazyContent(limit) → {Promise.<Array>}

Find lazy content that needs processing

Parameters:

Name	Type	Default	Description
`limit`	number	10	Maximum number of items to return

Source:

stores/SPARQLStore.js, line 1857

Returns:

Array of lazy content items

Type: Promise.<Array>

findNextBoundary()

Find next boundary position

Source:

zpt/transform/ContentChunker.js, line 516

findSemanticBoundaries()

Find semantic boundaries in text

Source:

zpt/transform/ContentChunker.js, line 465

(async) findSimilarElements(queryEmbedding, limit, threshold, filters) → {Promise.<Array>}

Advanced similarity search with SPARQL-based cosine similarity

Parameters:

Name	Type	Description
`queryEmbedding`	Array.<number>	Query embedding vector
`limit`	number	Maximum results
`threshold`	number	Similarity threshold
`filters`	Object	Additional filters

Source:

stores/SPARQLStore.js, line 1018

Returns:

Similar elements with similarity scores

Type: Promise.<Array>

findSimilarNodes(uri, kopt, optionsopt) → {Array}

Find nodes similar to a given node in the index

Parameters:

Name	Type	Attributes	Default	Description
`uri`	string			URI of the reference node
`k`	number	<optional>	10	Number of similar nodes to return
`options`	Object	<optional>		Search options

Source:

ragno/search/VectorIndex.js, line 234

Returns:

Similar nodes (excluding the reference node)

Type: Array

findSimilarNodes(uri, kopt, optionsopt) → {Array}

Find similar nodes

Parameters:

Name	Type	Attributes	Default	Description
`uri`	string			Reference node URI
`k`	number	<optional>	10	Number of similar nodes
`options`	Object	<optional>		Search options

Source:

ragno/search/index.js, line 304

Returns:

Similar nodes

Type: Array

findSingleBMU(inputVector) → {number}

Find Best Matching Unit for a single input vector

Parameters:

Name	Type	Description
`inputVector`	Array	Input vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 145

Returns:

Index of the best matching unit

Type: number

(async) findUnitsWithoutCorpuscles() → {Promise.<Array>}

Find units that don't have associated corpuscles

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 209

Returns:

Array of unit data

Type: Promise.<Array>

(async) fixedSizeChunking()

Fixed size chunking strategy

Source:

zpt/transform/ContentChunker.js, line 224

(async) flushSyncQueue()

Process queued sync operations in batch

Source:

stores/RagnoMemoryStore.js, line 73

(async) format(data, context) → {Object}

Main formatting method - routes to appropriate formatter

Parameters:

Name	Type	Description
`data`	Object	Response data to format
`context`	Object	Request context and metadata

Source:

zpt/api/ResponseFormatter.js, line 75

Returns:

Formatted response

Type: Object

(async) format(projectedContent, navigationContext, options) → {Object}

Main formatting method - transforms projected content for LLM consumption

Parameters:

Name	Type	Description
`projectedContent`	Object	Content from TiltProjector
`navigationContext`	Object	ZPT navigation context
`options`	Object	Formatting options

Source:

zpt/transform/PromptFormatter.js, line 127

Returns:

Formatted content ready for LLM

Type: Object

(async) formatAsAnalytical()

Format as analytical

Source:

zpt/transform/PromptFormatter.js, line 355

(async) formatAsConversational()

Format as conversational

Source:

zpt/transform/PromptFormatter.js, line 325

(async) formatAsJSON()

Format as JSON

Source:

zpt/transform/PromptFormatter.js, line 221

(async) formatAsMarkdown()

Format as Markdown

Source:

zpt/transform/PromptFormatter.js, line 249

(async) formatAsStructured()

Format as structured prompt

Source:

zpt/transform/PromptFormatter.js, line 288

formatContentAsMarkdown()

Content formatting helpers

Source:

zpt/transform/PromptFormatter.js, line 392

formatContentNaturally()

Content naturally formatted for conversation

Source:

zpt/transform/PromptFormatter.js, line 600

formatErrorResponse()

Format error response

Source:

zpt/api/ErrorHandler.js, line 466

(async) formatErrorResponse()

Format error responses

Source:

zpt/api/ResponseFormatter.js, line 165

formatGroupSummary()

Create summary for a group of related interactions

Source:

ContextManager.js, line 118

(async) formatHealthResponse()

Format health check responses

Source:

zpt/api/ResponseFormatter.js, line 323

formatMetadataAsMarkdown()

Metadata formatting

Source:

zpt/transform/PromptFormatter.js, line 865

(async) formatMetricsResponse()

Format metrics responses

Source:

zpt/api/ResponseFormatter.js, line 345

formatNavigationParameters()

Helper methods for data formatting

Source:

zpt/api/ResponseFormatter.js, line 364

(async) formatNavigationResponse()

Format navigation responses

Source:

zpt/api/ResponseFormatter.js, line 200

(async) formatOptionsResponse()

Format options responses

Source:

zpt/api/ResponseFormatter.js, line 262

(async) formatPreviewResponse()

Format preview responses

Source:

zpt/api/ResponseFormatter.js, line 240

formatRDFObject()

Format RDF object for SPARQL

Source:

zpt/selection/CorpuscleSelector.js, line 755

formatSI(num) → {string}

Format number with SI prefix

Parameters:

Name	Type	Description
`num`	number	Number to format

Source:

frontend/js/utils/_d3-helpers.js, line 127

Returns:

Formatted string

Type: string

(async) formatSchemaResponse()

Format schema responses

Source:

zpt/api/ResponseFormatter.js, line 301

formatSingleInteraction()

Format a single interaction for display

Source:

ContextManager.js, line 107

(async) formatStructured()

Format handlers

Source:

prompts/PromptManager.js, line 234

(async) formatSuccessResponse()

Format success responses

Source:

zpt/api/ResponseFormatter.js, line 139

formatTimeAgo()

Format timestamp as "time ago"

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 696

fromSimpleObject(obj, optionsopt) → {Attribute}

Create attribute from simple object (migration helper)

Parameters:

Name	Type	Attributes	Description
`obj`	Object		Simple object representation
`options`	Object	<optional>	Additional options

Source:

ragno/Attribute.js, line 411

Returns:

RDF-based attribute

Type: Attribute

fromSimpleObject(obj, optionsopt) → {Entity}

Create entity from simple object (migration helper for RagnoMemoryStore)

Parameters:

Name	Type	Attributes	Description
`obj`	Object		Simple object representation
`options`	Object	<optional>	Additional options

Source:

ragno/Entity.js, line 388

Returns:

RDF-based entity

Type: Entity

fromSimpleObject(obj, optionsopt) → {Relationship}

Create relationship from simple object (migration helper)

Parameters:

Name	Type	Attributes	Description
`obj`	Object		Simple object representation
`options`	Object	<optional>	Additional options

Source:

ragno/Relationship.js, line 329

Returns:

RDF-based relationship

Type: Relationship

fromSimpleObject(obj, optionsopt) → {SemanticUnit}

Create unit from simple object (migration helper)

Parameters:

Name	Type	Attributes	Description
`obj`	Object		Simple object representation
`options`	Object	<optional>	Additional options

Source:

ragno/SemanticUnit.js, line 438

Returns:

RDF-based unit

Type: SemanticUnit

(async) gatherCommunityContext(community, graphData, options) → {Promise.<Object>}

Gather comprehensive context for a community

Parameters:

Name	Type	Description
`community`	Object	Community object with members
`graphData`	Object	Graph data
`options`	Object	Context gathering options

Source:

ragno/aggregateCommunities.js, line 319

Returns:

Community context object

Type: Promise.<Object>

(async) gatherEntityContext(entity, graphData, options) → {Promise.<Object>}

Gather comprehensive context for an entity

Parameters:

Name	Type	Description
`entity`	Entity	Entity to gather context for
`graphData`	Object	Graph data
`options`	Object	Context gathering options

Source:

ragno/augmentWithAttributes.js, line 311

Returns:

Entity context object

Type: Promise.<Object>

gaussianRandom() → {number}

Generate Gaussian random number (Box-Muller transform)

Source:

ragno/algorithms/vsom/VSOMCore.js, line 329

Returns:

Random number from standard normal distribution

Type: number

generateCacheKey(method, query, options) → {string}

Generate cache key for request

Parameters:

Name	Type	Description
`method`	string	Search method
`query`	string	Search query
`options`	Object	Search options

Source:

ragno/search/SearchAPI.js, line 504

Returns:

Cache key

Type: string

(async) generateChat(model, messages, options) → {string}

Generate chat completion using Claude

Parameters:

Name	Type	Description
`model`	string	Model name to use
`messages`	Array	Array of message objects with role and content
`options`	Object	Additional options

Source:

connectors/ClaudeConnector.js, line 177

Returns:

Response text

Type: string

(async) generateChat(model, messages, options) → {string}

Generate chat completion using Mistral

Parameters:

Name	Type	Description
`model`	string	Model name to use (defaults to instance default)
`messages`	Array	Array of message objects with role and content
`options`	Object	Additional options

Source:

connectors/MistralConnector.js, line 94

Returns:

Response text

Type: string

(async) generateChat(model, messages, options) → {string}

Generate chat completion using Ollama

Parameters:

Name	Type	Description
`model`	string	Model name to use
`messages`	Array	Array of message objects with role and content
`options`	Object	Additional options

Source:

connectors/OllamaConnector.js, line 69

Returns:

Response text

Type: string

(async) generateChatResponse()

Generate a chat response with memory context

Source:

api/features/ChatAPI.js, line 76

(async, generator) generateChatStream(model, messages, options) → {AsyncGenerator.<string>}

Generate a streaming chat completion

Parameters:

Name	Type	Description
`model`	string	Model name to use (defaults to instance default)
`messages`	Array	Array of message objects with role and content
`options`	Object	Additional options

Source:

connectors/MistralConnector.js, line 126

Returns:

An async generator that yields chunks of the response

Type: AsyncGenerator.<string>

generateClusters(threshold) → {Array}

Generate clusters from trained map

Parameters:

Name	Type	Description
`threshold`	number	Clustering threshold

Source:

ragno/algorithms/VSOM.js, line 615

Returns:

Array of clusters

Type: Array

(async) generateCommunitySummary(community, context, llmHandler, options) → {Promise.<Object>}

Generate LLM summary for a community

Parameters:

Name	Type	Description
`community`	Object	Community object
`context`	Object	Community context
`llmHandler`	Object	LLM handler
`options`	Object	Generation options

Source:

ragno/aggregateCommunities.js, line 388

Returns:

Summary data with keywords and confidence

Type: Promise.<Object>

(async) generateCompletion()

Generate a text completion with memory context

Source:

api/features/ChatAPI.js, line 250

(async) generateCompletion(model, prompt, options) → {string}

Generate completion using Claude

Parameters:

Name	Type	Description
`model`	string	Model name to use
`prompt`	string	Text prompt
`options`	Object	Additional options

Source:

connectors/ClaudeConnector.js, line 256

Returns:

Response text

Type: string

(async) generateCompletion(model, prompt, options) → {string}

Generate completion (for backward compatibility)

Parameters:

Name	Type	Description
`model`	string	Model name to use
`prompt`	string	The prompt to complete
`options`	Object	Additional options

Source:

connectors/MistralConnector.js, line 161

Returns:

Completion text

Type: string

(async) generateCompletion()

Generate chat completion (not supported by Nomic embedding API)

Source:

connectors/NomicConnector.js, line 76

(async) generateCompletion(model, prompt, options) → {string}

Generate completion using Ollama

Parameters:

Name	Type	Description
`model`	string	Model name to use
`prompt`	string	Text prompt
`options`	Object	Additional options

Source:

connectors/OllamaConnector.js, line 105

Returns:

Response text

Type: string

generateConceptURI()

Generate a consistent URI for a concept based on its label

Source:

stores/SPARQLStore.js, line 1434

generateConceptURI()

Generate a URI for a concept based on its label

Source:

zpt/selection/TiltProjector.js, line 1017

generateCorpuscleId(unit) → {string}

Generate unique corpuscle ID

Parameters:

Name	Type	Description
`unit`	Object	Unit data

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 465

Returns:

Unique corpuscle ID

Type: string

generateCorpuscleTriples(corpuscle) → {Array}

Generate RDF triples for corpuscle

Parameters:

Name	Type	Description
`corpuscle`	Object	Corpuscle data

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 409

Returns:

Array of RDF triple strings

Type: Array

(async) generateEmbedding()

Generate embedding for text

Source:

api/features/MemoryAPI.js, line 190

(async) generateEmbedding(model, input) → {Array.<number>}

Generate embeddings using Claude

Parameters:

Name	Type	Description
`model`	string	Model name to use for embedding
`input`	string	Text to generate embedding for

Source:

connectors/ClaudeConnector.js, line 102

Returns:

Vector embedding

Type: Array.<number>

(async) generateEmbedding(model, input) → {Array.<number>}

Generate embeddings using Mistral

Parameters:

Name	Type	Default	Description
`model`	string	mistral-embed	Model name to use for embedding (defaults to 'mistral-embed')
`input`	string		Text to generate embedding for

Source:

connectors/MistralConnector.js, line 69

Returns:

Vector embedding

Type: Array.<number>

(async) generateEmbedding(model, input) → {Array.<number>|Array.<Array.<number>>}

Generate embeddings using Nomic Atlas API

Parameters:

Name	Type	Description
`model`	string	Model name to use for embedding (optional, uses default)
`input`	string \| Array.<string>	Text or array of texts to generate embeddings for

Source:

connectors/NomicConnector.js, line 47

Returns:

Vector embedding(s)

Type: Array.<number> | Array.<Array.<number>>

(async) generateEmbedding(model, input) → {Array.<number>}

Generate embeddings using Ollama

Parameters:

Name	Type	Description
`model`	string	Model name to use for embedding
`input`	string	Text to generate embedding for

Source:

connectors/OllamaConnector.js, line 44

Returns:

Vector embedding

Type: Array.<number>

(async) generateEmbedding(text, model, retriesopt) → {Promise.<Array.<number>>}

Parameters:

Name	Type	Attributes	Default
`text`	string
`model`	string
`retries`	number	<optional>	3

Source:

handlers/LLMHandler.js, line 293

Returns:

Type: Promise.<Array.<number>>

(async) generateEntityAttribute(entity, context, attributeType, llmHandler, options) → {Promise.<Object>}

Generate a specific type of attribute for an entity

Parameters:

Name	Type	Description
`entity`	Entity	Entity to generate attribute for
`context`	Object	Entity context
`attributeType`	string	Type of attribute to generate
`llmHandler`	Object	LLM handler
`options`	Object	Generation options

Source:

ragno/augmentWithAttributes.js, line 376

Returns:

Generated attribute data

Type: Promise.<Object>

generateErrorSuggestions()

Generate helpful suggestions based on error type

Source:

zpt/api/ErrorHandler.js, line 513

generateFuzzyPatterns()

Helper methods for pattern generation and expansion

Source:

zpt/selection/PanDomainFilter.js, line 877

(async) generateHypotheses()

Generate hypotheses using HyDE algorithm

Source:

api/features/RagnoAPI.js, line 595

(async) generateHypotheses(inputs, llmHandler, targetDataset, optionsopt) → {Object}

Generate hypothetical answers and augment RDF graph

Parameters:

Name	Type	Attributes	Description
`inputs`	Array \| string		Query strings or entity URIs to generate hypotheses for
`llmHandler`	Object		LLM handler instance for generation
`targetDataset`	Dataset		RDF dataset to augment
`options`	Object	<optional>	Generation options

Source:

ragno/algorithms/Hyde.js, line 76

Returns:

Results with generated hypotheses and RDF updates

Type: Object

generateNodeAssignments()

Generate node assignments for entities

Source:

ragno/algorithms/VSOM.js, line 598

(async) generateNodeEmbedding(node, embeddingHandler, options) → {Promise.<Object>}

Generate embedding for a node

Parameters:

Name	Type	Description
`node`	Object	Node object
`embeddingHandler`	Object	Embedding handler
`options`	Object	Generation options

Source:

ragno/enrichWithEmbeddings.js, line 394

Returns:

Embedding data object

Type: Promise.<Object>

(async) generatePrompt()

Generate a prompt using a template

Source:

prompts/PromptManager.js, line 146

(async) generateQuestions(input, resources, options) → {Promise.<Array>}

Generate and store follow-up questions from analysis results

Parameters:

Name Type Description

input

Object

Question generation input data

Properties

Name	Type	Description
`originalQuestion`	Object	The original question object with uri and text
`analysisResult`	Object	Results from ResponseAnalyzer with followUpQuestions
`iterationLevel`	number	Current iteration level (default: 1)

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Properties

Name	Type	Description
`maxIterations`	number	Maximum iterations allowed (default: 3)
`questionPrefix`	string	Prefix for generated questions (default: 'Generated:')

Source:

compose/feedback/FollowUpGenerator.js, line 31

Returns:

Generated questions with URIs and metadata

Type: Promise.<Array>

generateReport() → {Object}

Generate summary report

Source:

aux/wikipedia/Search.js, line 461

Returns:

Summary report

Type: Object

generateReport() → {Object}

Generate summary report

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 568

Returns:

Summary report

Type: Object

(async) generateResponse(prompt, context, optionsopt) → {Promise.<string>}

Parameters:

Name Type Attributes Description

prompt

string

The user's input prompt

context

string

Additional context for the prompt

options

Object

Additional options

Properties

Name	Type	Attributes	Description
`systemPrompt`	string	<optional>	System prompt to use
`model`	string	<optional>	Override the default model
`temperature`	number	<optional>	Override the default temperature

Source:

handlers/LLMHandler.js, line 80

Returns:

Type: Promise.<string>

generateResultId(result) → {string}

Generate unique ID for Wikipedia result

Parameters:

Name	Type	Description
`result`	Object	Wikipedia search result

Source:

aux/wikipedia/Search.js, line 384

Returns:

Unique result ID

Type: string

(async) generateSampleData()

Generate sample data for testing

Source:

api/features/VSOMAPI.js, line 219

(async) generateSampleEntities()

Generate sample entities for testing

Source:

api/features/VSOMAPI.js, line 642

(async) generateSingleHypothesis(input, llmHandler, options, index) → {Object}

Generate a single hypothesis using the LLM

Parameters:

Name	Type	Description
`input`	string	Input query or entity URI
`llmHandler`	Object	LLM handler instance
`options`	Object	Generation options
`index`	number	Hypothesis index for variation

Source:

ragno/algorithms/Hyde.js, line 189

Returns:

Generated hypothesis

Type: Object

generateTriplesFromQuads()

Generate SPARQL triples from RDF quads

Source:

zpt/selection/CorpuscleSelector.js, line 745

generateURI(name, baseURIopt) → {string}

Generate URI for entity based on name (useful for RagnoMemoryStore integration)

Parameters:

Name	Type	Attributes	Default	Description
`name`	string			Entity name
`baseURI`	string	<optional>	http://example.org/ragno/	Base URI

Source:

ragno/Entity.js, line 418

Returns:

Generated URI

Type: string

generateURI(type) → {string}

Generate a unique URI for a given resource type

Parameters:

Name	Type	Description
`type`	string	Resource type (entity, unit, relationship, etc.)

Source:

ragno/core/RDFGraphManager.js, line 47

Returns:

Generated URI

Type: string

generateURI(type) → {string}

Generate a unique URI for this element

Parameters:

Name	Type	Description
`type`	string	Element type

Source:

ragno/models/RDFElement.js, line 61

Returns:

Generated URI

Type: string

generateUnitTriples(unit, result, searchObject) → {Array}

Generate RDF triples for a Wikipedia unit

Parameters:

Name	Type	Description
`unit`	Object	Unit data
`result`	Object	Original Wikipedia result
`searchObject`	Object	Original search object

Source:

aux/wikipedia/Search.js, line 267

Returns:

Array of RDF triple strings

Type: Array

get()

Retrieve an API instance by name

Source:

api/common/APIRegistry.js, line 77

get(name)

Get a registered validator

Parameters:

Name	Type	Description
`name`	string	Validator name

Source:

api/common/CustomValidators.js, line 105

getAPIRouteHandlers() → {Object}

Get Express.js route handlers for HTTP API

Source:

ragno/search/index.js, line 505

Returns:

Route handlers

Type: Object

getAggregationConfig(zoomLevel) → {Object}

Get aggregation requirements for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 229

Returns:

Aggregation configuration

Type: Object

getAggregationFields(zoomLevel) → {Array.<string>}

Get aggregation fields for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 375

Returns:

Aggregation SPARQL fields

Type: Array.<string>

getAggregationGroupBy(zoomLevel) → {Array.<string>}

Get GROUP BY clause for aggregation

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 247

Returns:

Fields to group by

Type: Array.<string>

getAggregationMetrics(zoomLevel) → {Array.<Object>}

Get aggregation metrics for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 264

Returns:

Aggregation metrics configuration

Type: Array.<Object>

getAll()

Get all registered API instances

Source:

api/common/APIRegistry.js, line 88

getAllCustomMetadata() → {Object}

Get all custom metadata properties (excluding standard properties)

Source:

ragno/models/RDFElement.js, line 454

Returns:

Object with all custom metadata

Type: Object

getAllNamespaces() → {Object}

Get all namespace objects

Source:

ragno/core/NamespaceManager.js, line 196

Returns:

All namespaces

Type: Object

getAllStatistics() → {Object}

Get comprehensive statistics from all algorithm modules

Source:

ragno/algorithms/index.js, line 450

Returns:

Combined statistics

Type: Object

(async) getAllTrainingStatus() → {Promise.<Array>}

Get training status for all instances

Source:

services/vsom/VSOMService.js, line 390

Returns:

All training statuses

Type: Promise.<Array>

getAllTypes(zoomLevel) → {Array.<string>}

Get all RDF types for a zoom level (primary + secondary)

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 143

Returns:

Array of RDF type URIs

Type: Array.<string>

getAlternativeNames() → {Array.<string>}

Get all alternative names for this entity

Source:

ragno/Entity.js, line 197

Returns:

Alternative names

Type: Array.<string>

getAttributes() → {Array.<NamedNode>}

Get all attributes for this entity

Source:

ragno/Entity.js, line 278

Returns:

Attribute nodes

Type: Array.<NamedNode>

getAvailableFormats()

Get available formats

Source:

zpt/transform/PromptFormatter.js, line 899

getAvailableInstructions()

Get available instruction sets

Source:

zpt/transform/PromptFormatter.js, line 913

getAvailableModels() → {Array.<string>}

List available models

Source:

zpt/transform/TokenCounter.js, line 541

Returns:

Available model names

Type: Array.<string>

(async) getAvailableServices()

Get available services and their status

Source:

api/features/UnifiedSearchAPI.js, line 590

getAvailableStrategies() → {Array.<string>}

Get available chunking strategies

Source:

services/document/Chunker.js, line 377

Returns:

Available strategies

Type: Array.<string>

getAvailableStrategies()

Get available chunking strategies

Source:

zpt/transform/ContentChunker.js, line 1046

getAvailableStrategies()

Configuration and info methods

Source:

zpt/transform/MetadataEncoder.js, line 801

getAvailableTemplates() → {Array.<string>}

Get available template names

Source:

aux/wikidata/QueryTemplateManager.js, line 214

Returns:

List of available template names

Type: Array.<string>

getAvailableTokenizers() → {Array.<string>}

List available tokenizers

Source:

zpt/transform/TokenCounter.js, line 533

Returns:

Available tokenizer names

Type: Array.<string>

getBaseFields(zoomLevel) → {Array.<string>}

Get base fields for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 342

Returns:

Base SPARQL fields

Type: Array.<string>

getCacheKey()

Utility methods

Source:

prompts/PromptManager.js, line 542

getCacheStats() → {Object}

Get cache statistics

Source:

zpt/transform/TokenCounter.js, line 557

Returns:

Cache statistics

Type: Object

getCachedResult()

Cache management methods

Source:

zpt/selection/CorpuscleSelector.js, line 875

getCategory() → {string|null}

Get the attribute category/type

Source:

ragno/Attribute.js, line 172

Returns:

Attribute category

Type: string | null

getClusters(thresholdopt) → {Array}

Generate cluster assignments for entities

Parameters:

Name	Type	Attributes	Default	Description
`threshold`	number	<optional>	null	Clustering threshold

Source:

ragno/algorithms/VSOM.js, line 304

Returns:

Array of cluster assignments

Type: Array

(async) getCommunities()

Get communities from the graph

Source:

api/features/RagnoAPI.js, line 523

getConfidence() → {number|null}

Get confidence score for this attribute

Source:

ragno/Attribute.js, line 154

Returns:

Confidence score

Type: number | null

getConnectedElements() → {Array.<NamedNode>}

Get all connected elements

Source:

ragno/models/RDFElement.js, line 275

Returns:

Array of connected element URIs

Type: Array.<NamedNode>

getConnectedUnits() → {Array.<Object>}

Get all connected semantic units

Source:

ragno/SemanticUnit.js, line 251

Returns:

Connected units with relationship info

Type: Array.<Object>

getContent() → {string}

Get content of this element (or empty string if not set)

Source:

ragno/models/RDFElement.js, line 115

Returns:

Content text

Type: string

getContextRecommendation()

Get recommendation based on context utilization

Source:

zpt/transform/TokenCounter.js, line 418

getContextTruncationLimit()

Get context truncation limit from config

Source:

ContextManager.js, line 29

getCorpus() → {NamedNode|null}

Get corpus association for this attribute

Source:

ragno/Attribute.js, line 213

Returns:

Corpus node

Type: NamedNode | null

getCorpus() → {NamedNode|null}

Get corpus association for this entity

Source:

ragno/Entity.js, line 128

Returns:

Corpus node

Type: NamedNode | null

getCorpus() → {NamedNode|null}

Get corpus association for this unit

Source:

ragno/SemanticUnit.js, line 281

Returns:

Corpus node

Type: NamedNode | null

getCorpuscleType()

Get corpuscle type based on zoom level

Source:

zpt/selection/CorpuscleSelector.js, line 275

getDefaultConfig(provider) → {Object}

Get default configuration for a provider

Parameters:

Name	Type	Description
`provider`	string	Provider name

Source:

connectors/EmbeddingConnectorFactory.js, line 66

Returns:

Default configuration object

Type: Object

getDefaultConfig() → {Object}

Get default configuration

Source:

services/document/Chunker.js, line 385

Returns:

Default configuration

Type: Object

getDefaultFieldMappings()

Default field mappings for extracting document data from SPARQL results

Source:

services/ingestion/SPARQLDocumentIngester.js, line 47

getDefaultTiltURI()

Get default tilt URI for fallback cases

Source:

zpt/selection/CorpuscleSelector.js, line 662

getDefaultWeights()

Get default priority weights

Source:

zpt/parameters/SelectionCriteria.js, line 46

getDefaultZoomURI()

Get default zoom URI for fallback cases

Source:

zpt/selection/CorpuscleSelector.js, line 654

getDefaults()

Get default values for optional parameters

Source:

zpt/parameters/ParameterValidator.js, line 433

(async) getDocument()

Get document details

Source:

api/features/DocumentAPI.js, line 429

getEmbedding() → {Array.<number>|null}

Get vector embedding for this unit

Source:

ragno/SemanticUnit.js, line 179

Returns:

Vector embedding

Type: Array.<number> | null

getEndpointInfo()

Configuration and management

Source:

zpt/api/NavigationEndpoint.js, line 758

getEndpoints()

Get API endpoints configuration

Source:

api/features/WikidataAPI.js, line 338

getEndpoints()

Get API endpoints configuration

Source:

api/features/WikipediaAPI.js, line 476

(async) getEnhancedEntityContext(input, resources, options) → {Promise.<Object>}

Get enhanced entity context for questions

Parameters:

Name Type Description

input

Object

Context input data

Properties

Name	Type	Description
`entityURIs`	Array.<string>	Entity URIs to get context for
`question`	Object	Question object

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Source:

aux/wikidata/WikidataNavigator.js, line 174

Returns:

Enhanced entity context

Type: Promise.<Object>

(async) getEntities()

Get entities with optional filtering

Source:

api/features/RagnoAPI.js, line 309

getEntities() → {Array.<NamedNode>}

Get all entities in the dataset

Source:

ragno/core/RDFGraphManager.js, line 225

Returns:

Array of entity nodes

Type: Array.<NamedNode>

getEntity() → {NamedNode|null}

Get the entity this attribute describes

Source:

ragno/Attribute.js, line 118

Returns:

Entity node

Type: NamedNode | null

(async) getEntityProperties(entityId, options) → {Promise.<Object>}

Get entity properties and values

Parameters:

Name	Type	Description
`entityId`	string	Wikidata entity ID (e.g., 'Q146')
`options`	Object	Query options

Source:

aux/wikidata/WikidataConnector.js, line 262

Returns:

Entity properties

Type: Promise.<Object>

(async) getEntityRelationships(entityId, options) → {Promise.<Object>}

Get related entities

Parameters:

Name	Type	Description
`entityId`	string	Wikidata entity ID
`options`	Object	Query options

Source:

aux/wikidata/WikidataConnector.js, line 318

Returns:

Related entities

Type: Promise.<Object>

getErrorStats()

Statistics and monitoring

Source:

zpt/api/ErrorHandler.js, line 674

getEvidence() → {Array.<NamedNode>}

Get all evidence sources for this attribute

Source:

ragno/Attribute.js, line 231

Returns:

Evidence nodes

Type: Array.<NamedNode>

getEvidence() → {Array.<NamedNode>}

Get all evidence sources for this relationship

Source:

ragno/Relationship.js, line 231

Returns:

Evidence nodes

Type: Array.<NamedNode>

getExecutionStats(results) → {Object}

Get execution statistics from results

Parameters:

Name	Type	Description
`results`	Array.<Object>	Array of execution results

Source:

services/sparql/SPARQLHelper.js, line 380

Returns:

Statistics summary

Type: Object

(async) getFeatureMaps()

Get feature maps (U-Matrix, component planes)

Source:

api/features/VSOMAPI.js, line 315

(async) getFeatureMaps(instanceId, options) → {Promise.<Object>}

Get feature maps (U-Matrix, component planes)

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier
`options`	Object	Feature map options

Source:

services/vsom/VSOMService.js, line 284

Returns:

Feature maps

Type: Promise.<Object>

getFilterDocumentation()

Get filter configuration for documentation

Source:

zpt/selection/PanDomainFilter.js, line 1188

getFirstSeen() → {Date|null}

Get first seen timestamp

Source:

ragno/Entity.js, line 150

Returns:

First seen date

Type: Date | null

getFormatInfo()

Get format information

Source:

zpt/transform/PromptFormatter.js, line 906

getFrequency() → {number|null}

Get frequency for this entity

Source:

ragno/Entity.js, line 100

Returns:

Frequency count

Type: number | null

(async) getGraphStatistics(input, resources, options) → {Promise.<Object>}

Get statistics about a graph

Parameters:

Name Type Description

input

Object

Statistics input data

Properties

Name	Type	Description
`graphURI`	string	URI of the graph to analyze

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations

options

Object

Configuration options

Properties

Name	Type	Description
`includeTypes`	boolean	Include type counts (default: true)
`includePredicates`	boolean	Include predicate counts (default: true)

Source:

utils/GraphManager.js, line 230

Returns:

Graph statistics

Type: Promise.<Object>

(async) getGraphStats()

Get graph statistics

Source:

api/features/RagnoAPI.js, line 260

(async) getGridState()

Get current grid state

Source:

api/features/VSOMAPI.js, line 295

(async) getGridState(instanceId, options) → {Promise.<Object>}

Get grid state for visualization

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier
`options`	Object	Grid state options

Source:

services/vsom/VSOMService.js, line 255

Returns:

Grid state

Type: Promise.<Object>

(async) getHealth()

Get ZPT system health

Source:

api/features/ZptAPI.js, line 441

getHexagonalVisualCoords(x, y) → {Array}

Get visual coordinates for hexagonal topology

Parameters:

Name	Type	Description
`x`	number	Map X coordinate
`y`	number	Map Y coordinate

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 302

Returns:

[visualX, visualY] coordinates

Type: Array

getInfo() → {object}

Get connector information

Source:

connectors/NomicConnector.js, line 92

Returns:

Connector metadata

Type: object

(async) getInstanceHierarchy(entityIds, options) → {Promise.<Object>}

Get instance/subclass hierarchy for entities

Parameters:

Name	Type	Description
`entityIds`	string \| Array.<string>	Wikidata entity IDs
`options`	Object	Hierarchy options

Source:

aux/wikidata/WikidataSearch.js, line 231

Returns:

Hierarchical relationships

Type: Promise.<Object>

getInstructionInfo()

Get instruction set information

Source:

zpt/transform/PromptFormatter.js, line 920

getJSONLDContext() → {Object}

Create a JSON-LD context object

Source:

ragno/core/NamespaceManager.js, line 378

Returns:

JSON-LD context

Type: Object

getKeywords() → {Array.<string>}

Get all keywords/tags for this attribute

Source:

ragno/Attribute.js, line 266

Returns:

Keywords

Type: Array.<string>

getLanguage() → {string|null}

Get language for this attribute

Source:

ragno/Attribute.js, line 249

Returns:

Language code

Type: string | null

getLanguage() → {string|null}

Get language for this unit

Source:

ragno/SemanticUnit.js, line 299

Returns:

Language code

Type: string | null

getLastAccessed() → {Date|null}

Get last accessed timestamp

Source:

ragno/Entity.js, line 172

Returns:

Last accessed date

Type: Date | null

getLegacyAdapter()

Get legacy adapter for backward compatibility

Source:

prompts/PromptManager.js, line 713

getLength() → {number|null}

Get length of this unit in characters

Source:

ragno/SemanticUnit.js, line 159

Returns:

Character length

Type: number | null

getMentionedEntities() → {Array.<NamedNode>}

Get all entities mentioned by this unit

Source:

ragno/SemanticUnit.js, line 218

Returns:

Entity nodes

Type: Array.<NamedNode>

getMetadata() → {Object}

Get attribute metadata including ragno-specific properties

Source:

ragno/Attribute.js, line 364

Returns:

Attribute metadata

Type: Object

getMetadata() → {Object}

Get entity metadata including ragno-specific properties

Source:

ragno/Entity.js, line 347

Returns:

Entity metadata

Type: Object

getMetadata() → {Object}

Get relationship metadata

Source:

ragno/Relationship.js, line 295

Returns:

Relationship metadata

Type: Object

getMetadata() → {Object}

Get unit metadata including ragno-specific properties

Source:

ragno/SemanticUnit.js, line 394

Returns:

Unit metadata

Type: Object

getMetadata() → {Object}

Get element metadata (enhanced to include custom metadata)

Source:

ragno/models/RDFElement.js, line 536

Returns:

Element metadata including custom properties

Type: Object

getMetadataProperty(property) → {any}

Get a metadata property value

Parameters:

Name	Type	Description
`property`	string	Property name

Source:

ragno/models/RDFElement.js, line 418

Returns:

Property value or undefined

Type: any

getMetrics()

Get collected metrics with timestamps

Source:

api/common/APIRegistry.js, line 95

(async) getMetrics() → {Object}

Get system metrics

Source:

api/common/BaseAPI.js, line 70

Returns:

System metrics

Type: Object

(async) getMetrics()

Get chat API metrics

Source:

api/features/ChatAPI.js, line 338

(async) getMetrics()

Get memory API metrics

Source:

api/features/MemoryAPI.js, line 235

(async) getMetrics()

Get Ragno API metrics

Source:

api/features/RagnoAPI.js, line 830

(async) getMetrics()

Get search API metrics

Source:

api/features/SearchAPI.js, line 257

(async) getMetrics()

Get unified search metrics

Source:

api/features/UnifiedSearchAPI.js, line 729

(async) getMetrics()

Get ZPT API metrics

Source:

api/features/ZptAPI.js, line 617

getMetrics()

Get selector statistics

Source:

zpt/selection/CorpuscleSelector.js, line 924

getMetrics()

Configuration and info methods

Source:

zpt/transform/CorpuscleTransformer.js, line 849

(async) getModelConfig()

Get model configuration (from api-server.js)

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 111

getModelInfo(modelName) → {Object}

Get model information

Parameters:

Name	Type	Description
`modelName`	string	Model name

Source:

zpt/transform/TokenCounter.js, line 520

Returns:

Model information

Type: Object

getName() → {string}

Get the name for this entity (or empty string if not set)

Source:

ragno/Entity.js, line 83

Returns:

Type: string

getNamespace(prefix) → {function}

Get specific namespace by prefix

Parameters:

Name	Type	Description
`prefix`	string	Namespace prefix

Source:

ragno/core/NamespaceManager.js, line 395

Returns:

Namespace function

Type: function

getNavigationStatistics(input, resources, options) → {Object}

Get navigation statistics

Parameters:

Name	Type	Description
`input`	Object	Statistics input (can be empty)
`resources`	Object	External dependencies (unused)
`options`	Object	Configuration options

Source:

aux/wikidata/WikidataNavigator.js, line 272

Returns:

Navigation statistics

Type: Object

getNeighbors(coords, radius) → {Array}

Get all neighbors of a node within a given radius

Parameters:

Name	Type	Description
`coords`	Array	[x, y] coordinates of the center node
`radius`	number	Neighborhood radius

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 152

Returns:

Array of neighbor coordinates [[x, y], ...]

Type: Array

getNodeMappings() → {Array}

Get node mappings (entity to map position)

Source:

ragno/algorithms/VSOM.js, line 324

Returns:

Array of node mappings

Type: Array

getNodeMetadata(uri) → {Object|null}

Get metadata for a node

Parameters:

Name	Type	Description
`uri`	string	Node URI

Source:

ragno/search/VectorIndex.js, line 347

Returns:

Node metadata

Type: Object | null

getNodeMetadata(uri) → {Object|null}

Get node metadata

Parameters:

Name	Type	Description
`uri`	string	Node URI

Source:

ragno/search/index.js, line 292

Returns:

Node metadata

Type: Object | null

getNodeType(graph, nodeUri) → {string}

Get the primary ragno type for a node

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`nodeUri`	string	Node URI

Source:

ragno/algorithms/PersonalizedPageRank.js, line 336

Returns:

Node type

Type: string

getNodeWeights(nodeIndex) → {Array}

Get weight vector for a specific map node

Parameters:

Name	Type	Description
`nodeIndex`	number	Index of the map node

Source:

ragno/algorithms/vsom/VSOMCore.js, line 405

Returns:

Weight vector

Type: Array

getNodesByType(type, limitopt) → {Array}

Get nodes by type

Parameters:

Name	Type	Attributes	Description
`type`	string		Ragno type
`limit`	number	<optional>	Maximum number of nodes to return

Source:

ragno/search/VectorIndex.js, line 258

Returns:

Nodes of the specified type

Type: Array

getNodesByType(type, limitopt) → {Array}

Get nodes by type

Parameters:

Name	Type	Attributes	Description
`type`	string		Ragno type
`limit`	number	<optional>	Maximum number of nodes

Source:

ragno/search/index.js, line 315

Returns:

Nodes of specified type

Type: Array

getOntologyInfo() → {Object}

Get ontology metadata

Source:

ragno/core/NamespaceManager.js, line 426

Returns:

Ontology information

Type: Object

(async) getOntologyTerms()

Get available ZPT ontology terms

Source:

api/features/ZptAPI.js, line 1008

getOptimalResultLimit(zoomLevel, tokenBudget) → {number}

Get optimal result limit for a zoom level

Parameters:

Name	Type	Default	Description
`zoomLevel`	string		The zoom level
`tokenBudget`	number	4000	Available token budget

Source:

zpt/selection/ZoomLevelMapper.js, line 195

Returns:

(async) getOptions()

Get available navigation options

Source:

api/features/ZptAPI.js, line 358

getOtherEntity(entity) → {NamedNode|null}

Get the other entity in this relationship

Parameters:

Name	Type	Description
`entity`	RDFElement \| NamedNode \| string	Known entity

Source:

ragno/Relationship.js, line 191

Returns:

Other entity

Type: NamedNode | null

getPPRScore() → {number|null}

Get PPR score for this element

Source:

ragno/models/RDFElement.js, line 231

Returns:

PPR score

Type: number | null

getParameterSummary()

Get parameter summary for logging

Source:

zpt/parameters/ParameterNormalizer.js, line 379

getParserInfo()

Get parser configuration and stats

Source:

zpt/api/RequestParser.js, line 618

getPerformanceStats() → {Object}

Get performance statistics

Source:

zpt/transform/TokenCounter.js, line 570

Returns:

Performance statistics

Type: Object

getPosition() → {number|null}

Get position in source document

Source:

ragno/SemanticUnit.js, line 141

Returns:

Character position

Type: number | null

getPrefLabel() → {string}

Get the SKOS prefLabel for this entity (or empty string if not set)

Source:

ragno/Entity.js, line 74

Returns:

Type: string

getPrefLabel() → {string|null}

Get SKOS preferred label

Source:

ragno/models/RDFElement.js, line 134

Returns:

Label text

Type: string | null

getPreferredLabel() → {string}

Get the preferred label (SKOS prefLabel) for this entity

Source:

ragno/Entity.js, line 464

Returns:

The preferred label, or empty string if not set

Type: string

getPrefixes() → {Map}

Get prefix mapping for serialization

Source:

ragno/core/NamespaceManager.js, line 240

Returns:

Prefix to namespace URI mapping

Type: Map

getPrefixesAsObject() → {Object}

Get prefixes as object for JSON-LD context

Source:

ragno/core/NamespaceManager.js, line 248

Returns:

Prefix mapping object

Type: Object

getPrimaryTypes(zoomLevel) → {Array.<string>}

Get primary RDF types for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 153

Returns:

Array of primary RDF type URIs

Type: Array.<string>

(async) getProcessingStatus()

Get processing status for async operations

Source:

api/features/DocumentAPI.js, line 476

getProjectionDocumentation()

Get projection documentation

Source:

zpt/selection/TiltProjector.js, line 1053

getPromptManager()

Get or create global prompt manager

Source:

prompts/compatibility.js, line 19

getProvenance() → {Array.<NamedNode>}

Get provenance information for this attribute

Source:

ragno/Attribute.js, line 136

Returns:

Provenance nodes

Type: Array.<NamedNode>

(async) getQuery(templateName, parameters) → {Promise.<string>}

Load and process a query template

Parameters:

Name	Type	Description
`templateName`	string	Name of template file (without .sparql extension)
`parameters`	Object	Parameter values for substitution

Source:

aux/wikidata/QueryTemplateManager.js, line 63

Returns:

Processed SPARQL query

Type: Promise.<string>

(async) getQuery(templateName, parameters, options) → {Object}

Get a SPARQL query from template with parameter substitution

Parameters:

Name Type Description

templateName

string

Name of the template to use

parameters

Object

Parameters for template substitution

options

Object

Query generation options

Properties

Name	Type	Description
`includePrefixes`	boolean	Include prefix declarations (default: true)
`additionalPrefixes`	Array.<string>	Additional prefixes to include
`optimize`	boolean	Optimize query structure (default: false)

Source:

compose/sparql/TemplateManager.js, line 41

Returns:

Generated query with metadata

Type: Object

getQueryStats()

Get query statistics for optimization

Source:

zpt/parameters/FilterBuilder.js, line 672

(async) getQuestionStatistics(input, resources, options) → {Promise.<Object>}

Get statistics about generated questions

Parameters:

Name Type Description

input

Object

Statistics input data (can be empty)

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Source:

compose/feedback/FollowUpGenerator.js, line 300

Returns:

Statistics about question generation and research

Type: Promise.<Object>

(async) getQuestionsForResearch(input, resources, options) → {Promise.<Object>}

Get questions ready for research from the knowledge graph

Parameters:

Name Type Description

input

Object

Retrieval input data

Properties

Name	Type	Description
`iterationLevel`	number	Iteration level to retrieve (default: 1)
`limit`	number	Maximum questions to retrieve (default: 5)

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Source:

compose/feedback/FollowUpGenerator.js, line 142

Returns:

Retrieved questions with metadata

Type: Promise.<Object>

getRagnoLocalName(uri) → {string}

Get the local name from a ragno URI

Parameters:

Name	Type	Description
`uri`	string	Full ragno URI

Source:

ragno/core/NamespaceManager.js, line 315

Returns:

Local name

Type: string

getRecommendations(zoomLevel, panFilters, tiltRepresentation) → {Array.<string>}

Get optimization recommendations

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level
`panFilters`	Object	Pan filter parameters
`tiltRepresentation`	string	Tilt representation

Source:

zpt/selection/ZoomLevelMapper.js, line 427

Returns:

Optimization recommendations

Type: Array.<string>

getRecommendedTilt(zoomLevel) → {string}

Get recommended tilt representation for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 310

Returns:

Recommended tilt representation

Type: string

getRelationshipType() → {string|null}

Get the relationship type

Source:

ragno/Relationship.js, line 133

Returns:

Relationship type

Type: string | null

getRelationships(optionsopt) → {Array}

Get all relationships involving this entity

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Query options

Source:

ragno/Entity.js, line 232

Returns:

Relationship information

Type: Array

getRelationships() → {Array.<NamedNode>}

Get all relationships in the dataset

Source:

ragno/core/RDFGraphManager.js, line 234

Returns:

Array of relationship nodes

Type: Array.<NamedNode>

getRouteHandlers() → {Object}

Get Express.js route handlers

Source:

ragno/search/SearchAPI.js, line 73

Returns:

Route handlers for Express app

Type: Object

getRuleSelectivity()

Get estimated selectivity of a rule

Source:

zpt/parameters/SelectionCriteria.js, line 559

getSPARQLPrefixes() → {string}

Generate SPARQL prefixes string

Source:

ragno/core/NamespaceManager.js, line 366

Returns:

SPARQL prefix declarations

Type: string

getSPARQLPrefixes(prefixes) → {string}

Generate SPARQL prefix string

Parameters:

Name	Type	Description
`prefixes`	Array.<string>	Array of prefix names to include

Source:

zpt/ontology/ZPTNamespaces.js, line 592

Returns:

SPARQL prefix declarations

Type: string

(async) getSchema()

Get parameter schema and examples

Source:

api/features/ZptAPI.js, line 393

getSchema()

Get parameter schema for documentation

Source:

zpt/parameters/ParameterValidator.js, line 426

(async) getSearchStrategies()

Get search strategies information

Source:

api/features/UnifiedSearchAPI.js, line 623

getSelectionStrategy(zoomLevel) → {Object}

Get selection strategy for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 130

Returns:

Selection strategy configuration

Type: Object

(async) getSession()

Get specific navigation session details

Source:

api/features/ZptAPI.js, line 800

(async) getSessions()

Get list of navigation sessions

Source:

api/features/ZptAPI.js, line 758

getSimilarityScore() → {number|null}

Get similarity score for this element

Source:

ragno/models/RDFElement.js, line 249

Returns:

Similarity score

Type: number | null

getSourceDocument() → {NamedNode|null}

Get source document for this unit

Source:

ragno/SemanticUnit.js, line 123

Returns:

Source document node

Type: NamedNode | null

getSourceEntity() → {NamedNode|null}

Get the source entity for this relationship

Source:

ragno/Relationship.js, line 76

Returns:

Source entity node

Type: NamedNode | null

getStatistics(input, resources, options) → {Object}

Get research statistics

Parameters:

Name Type Description

input

Object

Statistics input (can be empty)

resources

Object

External dependencies (unused)

options

Object

Configuration options

Properties

Name	Type	Description
`includeSessionDetails`	boolean	Include session details (default: false)

Source:

aux/wikidata/WikidataResearcher.js, line 176

Returns:

Research statistics

Type: Object

getStatistics() → {Object}

Get processing statistics

Source:

aux/wikipedia/Search.js, line 394

Returns:

Current statistics

Type: Object

getStatistics() → {Object}

Get processing statistics

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 497

Returns:

Current statistics

Type: Object

getStatistics() → {Object}

Get current statistics

Source:

ragno/algorithms/CommunityDetection.js, line 629

Returns:

Current clustering statistics

Type: Object

getStatistics() → {Object}

Get current statistics

Source:

ragno/algorithms/GraphAnalytics.js, line 502

Returns:

Current analysis statistics

Type: Object

getStatistics() → {Object}

Get algorithm statistics

Source:

ragno/algorithms/Hyde.js, line 578

Returns:

Algorithm statistics

Type: Object

getStatistics() → {Object}

Get current statistics

Source:

ragno/algorithms/PersonalizedPageRank.js, line 517

Returns:

Current PPR statistics

Type: Object

getStatistics() → {Object}

Get algorithm statistics

Source:

ragno/algorithms/VSOM.js, line 810

Returns:

VSOM statistics

Type: Object

getStatistics() → {Object}

Get current algorithm statistics

Source:

ragno/algorithms/vsom/VSOMCore.js, line 431

Returns:

Performance and usage statistics

Type: Object

getStatistics() → {Object}

Get training statistics

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 452

Returns:

Training statistics

Type: Object

getStatistics() → {Object}

Get search statistics

Source:

ragno/search/DualSearch.js, line 789

Returns:

Current statistics

Type: Object

getStatistics() → {Object}

Get API statistics

Source:

ragno/search/SearchAPI.js, line 665

Returns:

API statistics

Type: Object

getStatistics()

Get filtering statistics

Source:

ragno/search/SearchFilters.js, line 578

getStatistics() → {Object}

Get index statistics

Source:

ragno/search/VectorIndex.js, line 453

Returns:

Index statistics

Type: Object

getStatistics() → {Object}

Get comprehensive system statistics

Source:

ragno/search/index.js, line 514

Returns:

System statistics

Type: Object

getStatistics()

Get ingestion statistics

Source:

services/ingestion/SPARQLDocumentIngester.js, line 406

getStats()

Get service statistics

Source:

aux/ResearchService.js, line 330

getStats() → {Object}

Get connector statistics

Source:

aux/wikidata/WikidataConnector.js, line 352

Returns:

Usage statistics

Type: Object

getStats() → {Object}

Get search statistics

Source:

aux/wikidata/WikidataSearch.js, line 457

Returns:

Search usage statistics

Type: Object

getStats() → {Object}

Get conversion statistics

Source:

aux/wikidata/WikidataToRagno.js, line 454

Returns:

Conversion statistics

Type: Object

getStats() → {Object}

Get dataset statistics

Source:

ragno/core/RDFGraphManager.js, line 267

Returns:

Statistics about the graph

Type: Object

getStats()

Get chunking statistics

Source:

zpt/transform/ContentChunker.js, line 1060

getStatus() → {Object}

Get system status

Source:

ragno/search/index.js, line 537

Returns:

System status

Type: Object

getStrategyInfo()

Get strategy information

Source:

zpt/transform/ContentChunker.js, line 1053

getSubType() → {string|null}

Get sub-type of this element

Source:

ragno/models/RDFElement.js, line 182

Returns:

Sub-type identifier

Type: string | null

getSummary() → {string|null}

Get summary for this attribute

Source:

ragno/Attribute.js, line 99

Returns:

Summary text

Type: string | null

getSummary() → {string|null}

Get summary for this unit

Source:

ragno/SemanticUnit.js, line 104

Returns:

Summary text

Type: string | null

getSummary()

Generate human-readable criteria summary

Source:

zpt/parameters/SelectionCriteria.js, line 574

getSupportedExtensions() → {Array.<string>}

Get supported file extensions

Source:

services/document/HTMLConverter.js, line 237

Returns:

Supported extensions

Type: Array.<string>

getSupportedExtensions() → {Array.<string>}

Get supported file extensions

Source:

services/document/PDFConverter.js, line 183

Returns:

Supported extensions

Type: Array.<string>

getSupportedProviders() → {Array.<string>}

Get list of supported embedding providers

Source:

connectors/EmbeddingConnectorFactory.js, line 48

Returns:

Array of supported provider names

Type: Array.<string>

getTargetEntity() → {NamedNode|null}

Get the target entity for this relationship

Source:

ragno/Relationship.js, line 98

Returns:

Target entity node

Type: NamedNode | null

getTargetTypes()

Get target element types for zoom level

Source:

zpt/parameters/ParameterNormalizer.js, line 233

getTemplate()

Get a template by name

Source:

prompts/PromptManager.js, line 132

(async) getTemplateMetadata(templateName) → {Promise.<Object>}

Get template metadata (parameters, description)

Parameters:

Name	Type	Description
`templateName`	string	Template name

Source:

aux/wikidata/QueryTemplateManager.js, line 223

Returns:

Template metadata

Type: Promise.<Object>

getTemporal() → {Date|null}

Get temporal information for this attribute

Source:

ragno/Attribute.js, line 194

Returns:

Temporal information

Type: Date | null

getText() → {string|null}

Get the main text content of this attribute

Source:

ragno/Attribute.js, line 81

Returns:

Text content

Type: string | null

getText() → {string|null}

Get the main text content of this unit

Source:

ragno/SemanticUnit.js, line 86

Returns:

Text content

Type: string | null

getTiltFields(tiltRepresentation) → {Array.<string>}

Get tilt-specific fields

Parameters:

Name	Type	Description
`tiltRepresentation`	string	The tilt representation

Source:

zpt/selection/ZoomLevelMapper.js, line 359

Returns:

Tilt-specific SPARQL fields

Type: Array.<string>

getTiltOutputFormat()

Get tilt output format

Source:

zpt/parameters/ParameterNormalizer.js, line 247

getTiltProcessingType()

Get tilt processing type

Source:

zpt/parameters/ParameterNormalizer.js, line 260

getTokenizerInfo(tokenizerName) → {Object}

Get tokenizer information

Parameters:

Name	Type	Description
`tokenizerName`	string	Tokenizer name

Source:

zpt/transform/TokenCounter.js, line 506

Returns:

Tokenizer information

Type: Object

getTopKNodes(scores, kopt) → {Array}

Get nodes with highest scores from analysis results

Parameters:

Name	Type	Attributes	Default	Description
`scores`	Map			Node URI -> score mapping
`k`	number	<optional>	10	Number of top nodes to return

Source:

ragno/algorithms/GraphAnalytics.js, line 434

Returns:

Top k nodes with scores

Type: Array

getTopKNodes(analysisResults, kopt) → {Object}

Get top-k important nodes across all metrics

Parameters:

Name	Type	Attributes	Default	Description
`analysisResults`	Object			Results from runFullAnalysis
`k`	number	<optional>	10	Number of top nodes to return

Source:

ragno/algorithms/index.js, line 305

Returns:

Top-k nodes with scores from different algorithms

Type: Object

getTopology() → {Object}

Get topology information

Source:

ragno/algorithms/VSOM.js, line 343

Returns:

Topology information

Type: Object

getTopologyInfo() → {Object}

Get topology information

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 357

Returns:

Topology information

Type: Object

(async) getTrainingStatus()

Get training status

Source:

api/features/VSOMAPI.js, line 368

getTrainingStatus() → {Object}

Get current training status

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 436

Returns:

Training status information

Type: Object

(async) getTrainingStatus(instanceId) → {Promise.<Object>}

Get training status for an instance

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier

Source:

services/vsom/VSOMService.js, line 373

Returns:

Training status

Type: Promise.<Object>

getTriples() → {Array}

Get all triples where this element is the subject

Source:

ragno/models/RDFElement.js, line 258

Returns:

Array of quads

Type: Array

getTriplesWithPredicate(predicate) → {Array}

Get all triples with specific predicate

Parameters:

Name	Type	Description
`predicate`	NamedNode	Predicate to match

Source:

ragno/models/RDFElement.js, line 267

Returns:

Array of matching quads

Type: Array

getTurtlePrefixes() → {string}

Generate Turtle prefixes string

Source:

ragno/core/NamespaceManager.js, line 354

Returns:

Turtle prefix declarations

Type: string

getTypes() → {Array.<NamedNode>}

Get all types of this element

Source:

ragno/models/RDFElement.js, line 294

Returns:

Array of RDF types

Type: Array.<NamedNode>

getURI() → {string}

Get the URI of this element

Source:

ragno/models/RDFElement.js, line 25

Returns:

The URI string

Type: string

getUnits() → {Array.<NamedNode>}

Get all units in the dataset

Source:

ragno/core/RDFGraphManager.js, line 243

Returns:

Array of unit nodes

Type: Array.<NamedNode>

(async) getView()

Get specific navigation view details

Source:

api/features/ZptAPI.js, line 903

(async) getViews()

Get list of navigation views

Source:

api/features/ZptAPI.js, line 861

getVisualizationCoordinates(outputFormat) → {Array}

Get visualization coordinates for the map nodes Converts map coordinates to visual coordinates suitable for plotting

Parameters:

Name	Type	Default	Description
`outputFormat`	string	cartesian	'cartesian', 'normalized', 'screen'

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 247

Returns:

Array of coordinate pairs for visualization

Type: Array

getWeight() → {number|null}

Get the weight for this relationship

Source:

ragno/Relationship.js, line 116

Returns:

Relationship weight

Type: number | null

getWikidataNamespaces() → {Object}

Get Wikidata-specific namespaces for SPARQL queries

Source:

ragno/core/NamespaceManager.js, line 219

Returns:

Wikidata namespaces

Type: Object

getWikidataProperties() → {Object}

Get commonly used Wikidata properties

Source:

ragno/core/NamespaceManager.js, line 232

Returns:

Wikidata property mappings

Type: Object

getZoomDescriptions()

Configuration and documentation helpers

Source:

zpt/api/ResponseFormatter.js, line 799

getZoomGranularity()

Get zoom granularity level

Source:

zpt/parameters/ParameterNormalizer.js, line 219

getZoomLevelDocumentation() → {Object}

Get zoom level metadata for API documentation

Source:

zpt/selection/ZoomLevelMapper.js, line 449

Returns:

Complete zoom level documentation

Type: Object

getZoomMapping(zoomLevel) → {Object}

Get mapping configuration for a zoom level

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level (corpus, community, unit, entity, text)

Source:

zpt/selection/ZoomLevelMapper.js, line 117

Returns:

Zoom level configuration

Type: Object

groupNodesByType(graph, scores) → {Map}

Group nodes by their ragno ontology type

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`scores`	Map	Node scores

Source:

ragno/algorithms/PersonalizedPageRank.js, line 314

Returns:

Type to node scores mapping

Type: Map

(async) handleDomainSwitch()

Handle domain switch

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 442

(async) handleDualSearch(req, res)

Main dual search endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 98

(async) handleEntityDetails(req, res)

Entity details endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 288

(async) handleError(error, req, res, context)

Main error handling method

Parameters:

Name	Type	Description
`error`	Error	The error to handle
`req`	Object	HTTP request object
`res`	Object	HTTP response object
`context`	Object	Additional context

Source:

zpt/api/ErrorHandler.js, line 207

(async) handleExactSearch(req, res)

Exact search endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 167

(async) handleFadeMemory()

Handle fade memory form submission

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 388

(async) handleForget()

Handle forget form submission

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 205

(async) handleGraphStats(req, res)

Graph statistics endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 341

(async) handleHealth()

Handle health check requests

Source:

zpt/api/NavigationEndpoint.js, line 367

(async) handleMemoryFilter()

Handle memory filter changes

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 459

(async) handleMetrics()

Handle metrics requests

Source:

zpt/api/NavigationEndpoint.js, line 495

(async) handleNavigate()

Handle main navigation requests

Source:

zpt/api/NavigationEndpoint.js, line 235

(async) handleOptions()

Handle options requests

Source:

zpt/api/NavigationEndpoint.js, line 299

(async) handlePreview()

Handle preview requests (limited processing)

Source:

zpt/api/NavigationEndpoint.js, line 266

(async) handleProjectContext()

Handle project context form submission

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 320

(async) handleRecall()

Handle recall form submission

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 257

(async) handleRemember()

Handle remember form submission

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 133

(async) handleRequest(req, res)

Main request handler - routes requests to appropriate endpoints

Parameters:

Name	Type	Description
`req`	Object	HTTP request object
`res`	Object	HTTP response object

Source:

zpt/api/NavigationEndpoint.js, line 164

(async) handleSchema()

Handle schema requests

Source:

zpt/api/NavigationEndpoint.js, line 326

(async) handleSearchStats(req, res)

Search statistics endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 426

(async) handleSearchStatus(req, res)

Search status endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 397

(async) handleSimilaritySearch(req, res)

Vector similarity search endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 201

(async) handleTraversalSearch(req, res)

PPR traversal search endpoint handler

Parameters:

Name	Type	Description
`req`	Object	Express request object
`res`	Object	Express response object

Source:

ragno/search/SearchAPI.js, line 243

hasFilters()

Check if pan has any active filters

Source:

zpt/parameters/ParameterNormalizer.js, line 300

hasNode(uri) → {boolean}

Check if a node exists in the index

Parameters:

Name	Type	Description
`uri`	string	Node URI

Source:

ragno/search/VectorIndex.js, line 338

Returns:

True if node exists

Type: boolean

hasNode(uri) → {boolean}

Check if node exists in index

Parameters:

Name	Type	Description
`uri`	string	Node URI

Source:

ragno/search/index.js, line 282

Returns:

True if node exists

Type: boolean

hasRelationshipWith(otherEntity) → {boolean}

Check if this entity has a relationship with another entity

Parameters:

Name	Type	Description
`otherEntity`	Entity \| NamedNode \| string	Other entity to check

Source:

ragno/Entity.js, line 248

Returns:

True if relationship exists

Type: boolean

hasStructure()

Utility methods

Source:

zpt/transform/ContentChunker.js, line 865

hasType(type) → {boolean}

Check if this element has a specific type

Parameters:

Name	Type	Description
`type`	NamedNode	RDF type to check

Source:

ragno/models/RDFElement.js, line 285

Returns:

True if element has this type

Type: boolean

hashObject(obj) → {string}

Hash object for cache key generation

Parameters:

Name	Type	Description
`obj`	Object	Object to hash

Source:

ragno/search/SearchAPI.js, line 612

Returns:

Hash string

Type: string

hashObject()

Simple hash function for cache keys

Source:

zpt/parameters/FilterBuilder.js, line 638

healthCheck()

Health check

Source:

prompts/PromptManager.js, line 720

(async) hierarchicalChunking()

Hierarchical chunking strategy

Source:

zpt/transform/ContentChunker.js, line 377

highlightQuery()

Highlight search query in text

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 686

(async) identifyImportantEntities(graphData, method, topK, minScore) → {Promise.<Array>}

Identify important entities using graph analysis algorithms

Parameters:

Name	Type	Description
`graphData`	Object	Graph data with entities and relationships
`method`	string	Importance calculation method
`topK`	number	Number of top entities to select
`minScore`	number	Minimum importance score threshold

Source:

ragno/augmentWithAttributes.js, line 162

Returns:

Array of important entity data objects

Type: Promise.<Array>

(async) identifyRetrievableNodes(graphData, retrievableTypes) → {Promise.<Array>}

Identify retrievable nodes from graph data

Parameters:

Name	Type	Description
`graphData`	Object	Graph data
`retrievableTypes`	Array.<string>	Types to include

Source:

ragno/enrichWithEmbeddings.js, line 227

Returns:

Array of retrievable node objects

Type: Promise.<Array>

incrementFrequency(incrementopt)

Increment frequency counter

Parameters:

Name	Type	Attributes	Default	Description
`increment`	number	<optional>	1	Amount to increment

Source:

ragno/Entity.js, line 109

(async) indexContent()

Index content for search

Source:

api/features/SearchAPI.js, line 200

indexToCoordinates(index) → {Array}

Convert linear index to 2D map coordinates

Parameters:

Name	Type	Description
`index`	number	Linear index

Source:

ragno/algorithms/vsom/VSOMCore.js, line 297

Returns:

[x, y] coordinates

Type: Array

indexToCoordinates(index) → {Array}

Convert linear index to 2D coordinates

Parameters:

Name	Type	Description
`index`	number	Linear index

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 224

Returns:

[x, y] coordinates

Type: Array

(async) ingest(searchObject) → {Promise.<Object>}

Ingest search results into SPARQL store as RDF

Parameters:

Name	Type	Description
`searchObject`	Object	Search results from search() method

Source:

aux/wikipedia/Search.js, line 144

Returns:

Ingestion results

Type: Promise.<Object>

(async) ingest(chunkingResult, options) → {Promise.<Object>}

Ingest chunked document data into SPARQL store

Parameters:

Name	Type	Description
`chunkingResult`	Object	Result from Chunker.chunk()
`options`	Object	Ingestion options

Source:

services/document/Ingester.js, line 30

Returns:

Ingestion result

Type: Promise.<Object>

(async) ingestDocument()

Ingest chunks into SPARQL store

Source:

api/features/DocumentAPI.js, line 343

(async) ingestFromTemplate(templateName, options) → {Promise.<Object>}

Ingest documents using a SPARQL template

Parameters:

Name Type Description

templateName

string

Name of SPARQL template to use

options

Object

Ingestion options

Properties

Name	Type	Description
`variables`	Object	Variables to substitute in template
`limit`	number	Maximum number of documents to ingest
`lazy`	boolean	Use lazy processing (no immediate embedding/concepts)
`tellFunction`	function	MCP tell function to use
`progressCallback`	function	Called for each processed document

Source:

services/ingestion/SPARQLDocumentIngester.js, line 214

Returns:

Ingestion results with statistics

Type: Promise.<Object>

init()

Initialize the VSOM feature

Source:

frontend/js/features/_vsom/index.js, line 11

(async) init()

Initialize the chat component

Source:

frontend/workbench/public/js/components/ChatComponent.js, line 27

(async) init()

Initialize the memory component

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 35

(async) init()

Initialize all required services and handlers

Source:

ragno/Memorise.js, line 68

initChatForms()

Initialize chat functionality

Source:

frontend/js/components/_chat.js, line 586

initMCPClient()

Initialize MCP Client

Source:

frontend/js/components/_mcpClient.js, line 359

initRangeInputs()

Initialize range inputs with value display

Source:

frontend/js/_app.js, line 129

initSettingsForm()

Initialize settings form

Source:

frontend/js/components/_settings.js, line 10

initTabs()

Initialize tab navigation

Source:

frontend/js/components/_tabs.js, line 8

(async, abstract) initialize()

Initialize the API instance

Source:

api/common/BaseAPI.js, line 20

(async) initialize() → {Promise.<void>}

Initialize the Claude client

Source:

connectors/ClaudeConnector.js, line 32

Returns:

Type: Promise.<void>

(async) initialize()

Initialize the Claude client

Source:

connectors/ClaudeConnector.js, line 62

(async) initialize() → {Promise.<void>}

Initialize the Mistral client

Source:

connectors/MistralConnector.js, line 31

Returns:

Type: Promise.<void>

(async) initialize()

Initialize the Nomic client

Source:

connectors/NomicConnector.js, line 23

(async) initialize()

Initialize the Ollama client

Source:

connectors/OllamaConnector.js, line 23

(async) initialize(optionsopt)

Initialize the complete search system

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Initialization options

Source:

ragno/search/index.js, line 108

(async) initialize(dependencies)

Initialize dependencies

Parameters:

Name	Type	Description
`dependencies`	Object	Required components

Source:

zpt/api/NavigationEndpoint.js, line 109

initializeApp()

Initialize the entire application

Source:

frontend/js/_app.js, line 70

(async) initializeAtuin()

Initialize Atuin components and real event bus

Source:

frontend/js/_app.js, line 24

initializeBoundaryDetectors()

Initialize boundary detection patterns

Source:

zpt/transform/ContentChunker.js, line 72

initializeChunkingStrategies()

Initialize different chunking strategies

Source:

zpt/transform/ContentChunker.js, line 29

initializeCompressionLevels()

Initialize compression levels

Source:

zpt/transform/MetadataEncoder.js, line 108

(async) initializeConfig()

Initialize configuration following semem patterns

Source:

ragno/Memorise.js, line 99

initializeDefaultRules()

Initialize default selection rules

Source:

zpt/parameters/SelectionCriteria.js, line 13

initializeDefaults()

Initialize default values for parameters

Source:

zpt/parameters/ParameterNormalizer.js, line 12

(async) initializeDocumentProcessing()

Initialize document processing components

Source:

ragno/Memorise.js, line 257

initializeDomainPatterns()

Initialize domain-specific patterns and vocabularies

Source:

zpt/selection/PanDomainFilter.js, line 76

(async) initializeEmbeddingHandler()

Initialize embedding handler

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 129

(async) initializeEmbeddingHandler()

Initialize embedding handler with provider selection

Source:

ragno/Memorise.js, line 198

initializeEncodingStrategies()

Initialize metadata encoding strategies

Source:

zpt/transform/MetadataEncoder.js, line 25

initializeEndpoints()

Initialize endpoint configurations

Source:

zpt/api/NavigationEndpoint.js, line 58

initializeErrorCodes()

Initialize specific error codes

Source:

zpt/api/ErrorHandler.js, line 133

initializeErrorTypes()

Initialize error type definitions

Source:

zpt/api/ErrorHandler.js, line 34

initializeFallbackConceptTemplates()

Initialize fallback concept templates if external files not available

Source:

zpt/parameters/FilterBuilder.js, line 198

initializeFilterStrategies()

Initialize filtering strategies for different pan dimensions

Source:

zpt/selection/PanDomainFilter.js, line 38

initializeFormats()

Initialize available output formats

Source:

zpt/transform/PromptFormatter.js, line 24

initializeFormatters()

Initialize format handlers

Source:

prompts/PromptManager.js, line 65

initializeFormatters()

Initialize response formatters for different content types

Source:

zpt/api/ResponseFormatter.js, line 23

initializeInstructions()

Initialize instruction sets for different use cases

Source:

zpt/transform/PromptFormatter.js, line 91

(async) initializeLLMHandler()

Initialize LLM handler with priority-based provider selection

Source:

ragno/Memorise.js, line 141

initializeLegacyAdapters()

Initialize legacy adapters for backward compatibility

Source:

prompts/PromptManager.js, line 77

initializeLinearWeights()

Initialize weights with linear interpolation across map

Source:

ragno/algorithms/vsom/VSOMCore.js, line 97

initializeMemoryDomains()

Initialize memory domain configurations for ChatGPT-style memory features

Source:

zpt/selection/PanDomainFilter.js, line 104

initializeMetadataSchemas()

Initialize metadata schemas for different contexts

Source:

zpt/transform/MetadataEncoder.js, line 75

initializeModelMappings()

Initialize model-specific token counting configurations

Source:

zpt/transform/TokenCounter.js, line 73

initializeNamespaces()

Initialize namespace prefixes for SPARQL queries

Source:

zpt/parameters/FilterBuilder.js, line 19

initializeOutputFormats()

Initialize output format specifications

Source:

zpt/selection/TiltProjector.js, line 66

initializePCAWeights()

Initialize weights using PCA (placeholder - would need input data)

Source:

ragno/algorithms/vsom/VSOMCore.js, line 114

initializePipeline()

Initialize transformation pipeline stages

Source:

zpt/transform/CorpuscleTransformer.js, line 67

initializeProjectionStrategies()

Initialize projection strategies for each tilt representation

Source:

zpt/selection/TiltProjector.js, line 23

initializePromptSystem()

Initialize the unified prompt system This function sets up the global prompt manager and loads existing templates

Source:

prompts/index.js, line 66

initializeQueryTemplates()

Initialize SPARQL query templates for different zoom levels

Source:

zpt/parameters/FilterBuilder.js, line 36

initializeRandomWeights()

Initialize weights with random values (Gaussian distribution)

Source:

ragno/algorithms/vsom/VSOMCore.js, line 84

initializeRecoveryStrategies()

Initialize error recovery strategies

Source:

zpt/api/ErrorHandler.js, line 189

(async) initializeSPARQLServices()

Initialize SPARQL services following infrastructure patterns

Source:

ragno/Memorise.js, line 114

initializeSchemas()

Initialize parameter schemas based on ZPT specification

Source:

zpt/parameters/ParameterValidator.js, line 12

initializeSelectionStrategies()

Initialize selection strategies for each zoom level

Source:

zpt/selection/ZoomLevelMapper.js, line 67

initializeTemplates()

Initialize response templates

Source:

zpt/api/ResponseFormatter.js, line 39

initializeTemplates()

Initialize formatting templates

Source:

zpt/transform/PromptFormatter.js, line 62

initializeTokenizers()

Initialize available tokenizers and their configurations

Source:

zpt/transform/TokenCounter.js, line 23

initializeValidators()

Initialize request validators

Source:

zpt/api/RequestParser.js, line 26

initializeWeights(mapSize, inputDimension, initMethod)

Initialize the SOM weight matrix with random values

Parameters:

Name	Type	Default	Description
`mapSize`	Array		[width, height] dimensions
`inputDimension`	number		Dimension of input vectors
`initMethod`	string	random	Initialization method ('random', 'linear', 'pca')

Source:

ragno/algorithms/vsom/VSOMCore.js, line 56

initializeZoomMappings()

Initialize zoom level to RDF type mappings

Source:

zpt/selection/ZoomLevelMapper.js, line 14

integrateWithGraphAnalytics(graphResults) → {Object}

Integrate with GraphAnalytics results

Parameters:

Name	Type	Description
`graphResults`	Object	Results from GraphAnalytics

Source:

ragno/algorithms/VSOM.js, line 496

Returns:

Integration results

Type: Object

(async) integrateWithHyde(hydeResults) → {Object}

Integrate with Hyde algorithm results

Parameters:

Name	Type	Description
`hydeResults`	Object	Results from Hyde algorithm

Source:

ragno/algorithms/VSOM.js, line 473

Returns:

Integration results

Type: Object

involves(entity) → {boolean}

Check if this relationship involves a specific entity

Parameters:

Name	Type	Description
`entity`	RDFElement \| NamedNode \| string	Entity to check

Source:

ragno/Relationship.js, line 210

Returns:

True if entity is source or target

Type: boolean

isAvailable() → {boolean}

Check if the connector is available

Source:

connectors/NomicConnector.js, line 84

Returns:

Whether the connector can be used

Type: boolean

isCode()

Detect if text is likely code

Source:

zpt/transform/TokenCounter.js, line 310

isEntryPoint() → {boolean}

Check if this element is an entry point

Source:

ragno/models/RDFElement.js, line 161

Returns:

Entry point status

Type: boolean

isProviderSupported(provider) → {boolean}

Check if a provider is supported

Parameters:

Name	Type	Description
`provider`	string	Provider name to check

Source:

connectors/EmbeddingConnectorFactory.js, line 57

Returns:

Whether the provider is supported

Type: boolean

isRagnoClass(uri) → {boolean}

Check if a URI is a ragno class

Parameters:

Name	Type	Description
`uri`	string	URI to check

Source:

ragno/core/NamespaceManager.js, line 297

Returns:

True if ragno class

Type: boolean

isRagnoProperty(uri) → {boolean}

Check if a URI is a ragno property

Parameters:

Name	Type	Description
`uri`	string	URI to check

Source:

ragno/core/NamespaceManager.js, line 306

Returns:

True if ragno property

Type: boolean

isRagnoURI(uri) → {boolean}

Check if a URI belongs to the ragno namespace

Parameters:

Name	Type	Description
`uri`	string	URI to check

Source:

ragno/core/NamespaceManager.js, line 288

Returns:

True if ragno namespace

Type: boolean

isRelevantAt(date) → {boolean}

Check if this attribute is relevant to a specific time period

Parameters:

Name	Type	Description
`date`	Date	Date to check

Source:

ragno/Attribute.js, line 276

Returns:

True if attribute is relevant at the given date

Type: boolean

isStopWord(word) → {boolean}

Check if word is a stop word

Parameters:

Name	Type	Description
`word`	string	Word to check

Source:

ragno/aggregateCommunities.js, line 476

Returns:

True if stop word

Type: boolean

isStopWord(word) → {boolean}

Check if word is a stop word

Parameters:

Name	Type	Description
`word`	string	Word to check

Source:

ragno/augmentWithAttributes.js, line 480

Returns:

True if stop word

Type: boolean

isSupported(filePath) → {boolean}

Check if file extension is supported

Parameters:

Name	Type	Description
`filePath`	string	File path to check

Source:

services/document/HTMLConverter.js, line 246

Returns:

True if supported

Type: boolean

isSupported(filePath) → {boolean}

Check if file extension is supported

Parameters:

Name	Type	Description
`filePath`	string	File path to check

Source:

services/document/PDFConverter.js, line 192

Returns:

True if supported

Type: boolean

isTboxFusekiAvailable()

Check if tbox Fuseki server is available

Source:

Config.js, line 388

isValidCoordinate(x, y) → {boolean}

Check if coordinates are valid for the current map

Parameters:

Name	Type	Description
`x`	number	X coordinate
`y`	number	Y coordinate

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 192

Returns:

True if coordinates are valid

Type: boolean

legacyFormatChatPrompt()

Legacy compatibility methods

Source:

prompts/PromptManager.js, line 411

(async) limitResults()

Limit results to maximum number

Source:

ragno/search/SearchFilters.js, line 300

(async) listDocuments()

List processed documents

Source:

api/features/DocumentAPI.js, line 398

(async) listExternalTemplateFiles()

List available external template files

Source:

prompts/PromptManager.js, line 637

(async) listInstances()

List all VSOM instances

Source:

api/features/VSOMAPI.js, line 389

(async) listInstances() → {Promise.<Array>}

List all VSOM instances

Source:

services/vsom/VSOMService.js, line 405

Returns:

List of instances

Type: Promise.<Array>

listTemplates() → {Array.<Object>}

List available templates

Source:

compose/sparql/TemplateManager.js, line 142

Returns:

List of available templates with metadata

Type: Array.<Object>

listTemplates()

List all templates

Source:

prompts/PromptManager.js, line 139

loadChatProviders()

Load chat providers (legacy function for compatibility)

Source:

frontend/js/components/_chat.js, line 601

loadConceptQueries()

Load concept-specific SPARQL query templates from external files

Source:

zpt/parameters/FilterBuilder.js, line 163

(async) loadConfigFromServer()

Load config from server and populate UI

Source:

frontend/js/components/_settings.js, line 185

(async) loadData()

Load data into a VSOM instance

Source:

api/features/VSOMAPI.js, line 173

(async) loadData(instanceId, entities) → {Promise.<Object>}

Load data into a VSOM instance

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier
`entities`	Array	Array of entity objects with embeddings

Source:

services/vsom/VSOMService.js, line 84

Returns:

Loading result

Type: Promise.<Object>

(async) loadDocQAData()

Load Document-QA data from SPARQL store

Source:

api/features/VSOMAPI.js, line 493

loadEnvironmentVariables()

Load environment variables from .env file

Source:

Config.js, line 511

(async) loadExternalTemplate()

Load a specific template from external files

Source:

prompts/PromptManager.js, line 589

(async) loadExternalTemplates()

Load external templates from prompts/templates/ directory

Source:

prompts/PromptManager.js, line 558

(async) loadFromEntities(entities, embeddingHandler, optionsopt) → {Promise.<Object>}

Load entities from an array with embedding generation

Parameters:

Name	Type	Attributes	Description
`entities`	Array		Array of Entity objects or entity data
`embeddingHandler`	Object		Embedding handler for vector generation
`options`	Object	<optional>	Loading options

Source:

ragno/algorithms/VSOM.js, line 120

Returns:

Loading results

Type: Promise.<Object>

(async) loadFromRagno()

Load concept graph from SPARQL on initialization

Source:

stores/RagnoMemoryStore.js, line 301

(async) loadFromSPARQL(endpoint, query, embeddingHandler, optionsopt) → {Promise.<Object>}

Load entities from SPARQL endpoint

Parameters:

Name	Type	Attributes	Description
`endpoint`	string		SPARQL endpoint URL
`query`	string		SPARQL query to retrieve entities
`embeddingHandler`	Object		Embedding handler for vector generation
`options`	Object	<optional>	Loading options

Source:

ragno/algorithms/VSOM.js, line 188

Returns:

Loading results

Type: Promise.<Object>

(async) loadFromVectorIndex(vectorIndex, filtersopt) → {Promise.<Object>}

Load entities from existing VectorIndex

Parameters:

Name	Type	Attributes	Description
`vectorIndex`	Object		VectorIndex instance
`filters`	Object	<optional>	Filters to apply

Source:

ragno/algorithms/VSOM.js, line 213

Returns:

Loading results

Type: Promise.<Object>

(async) loadIndex(indexPath, metadataPath)

Load index from file

Parameters:

Name	Type	Description
`indexPath`	string	Path to HNSW index file
`metadataPath`	string	Path to metadata file

Source:

ragno/search/VectorIndex.js, line 396

(async) loadMemoryState()

Load current memory state

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 533

loadSettings()

Load saved settings from localStorage

Source:

frontend/js/components/_settings.js, line 457

loadTemplate(templateName) → {string}

Load a SPARQL query template from file

Parameters:

Name	Type	Description
`templateName`	string	Name of template (without .sparql extension)

Source:

services/ingestion/SPARQLDocumentIngester.js, line 72

Returns:

SPARQL query string

Type: string

(async) loadTemplatesFromPromptTemplates()

Load templates from various sources

Source:

prompts/PromptManager.js, line 649

(async) loadUnitsToSPARQL(units) → {Promise.<Object>}

Load units to SPARQL store

Parameters:

Name	Type	Description
`units`	Array	Array of unit data

Source:

aux/wikipedia/Search.js, line 328

Returns:

Load operation results

Type: Promise.<Object>

(async) loadVectorIndex()

Load vector index from disk

Source:

ragno/search/index.js, line 343

localMovingPhase(graph, nodeToCommId, options) → {Object}

Local moving phase of Leiden algorithm

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`nodeToCommId`	Map	Current node to community mapping
`options`	Object	Algorithm options

Source:

ragno/algorithms/CommunityDetection.js, line 173

Returns:

Updated node to community mapping

Type: Object

logProcessingSummary()

Log processing summary

Source:

ragno/Memorise.js, line 630

logTrainingProgress(iteration, learningRate, neighborhoodRadius, results)

Log training progress

Parameters:

Name	Type	Description
`iteration`	number	Current iteration
`learningRate`	number	Learning rate
`neighborhoodRadius`	number	Neighborhood radius
`results`	Object	Iteration results

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 365

(async) lookupEntity(params) → {Promise.<Object>}

Look up a specific entity by ID or name

Parameters:

Name Type Description

params

Object

Lookup parameters

Properties

Name	Type	Description
`entityId`	string	Wikidata entity ID (e.g., Q42)
`entityName`	string	Entity name to search for
`language`	string	Language code (default: 'en')

Source:

aux/ResearchService.js, line 177

Returns:

Entity details

Type: Promise.<Object>

manhattanDistance(vector1, vector2) → {number}

Calculate Manhattan distance

Parameters:

Name	Type	Description
`vector1`	Array	First vector
`vector2`	Array	Second vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 228

Returns:

Manhattan distance

Type: number

(async) markQuestionResearched(input, resources, options) → {Promise.<Object>}

Mark a question as researched with results

Parameters:

Name Type Description

input

Object

Research completion input data

Properties

Name	Type	Description
`questionURI`	string	URI of the question that was researched
`researchResults`	Object	Results from research operation

resources

Object

External dependencies

Properties

Name	Type	Description
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs

options

Object

Configuration options

Source:

compose/feedback/FollowUpGenerator.js, line 239

Returns:

Success status and metadata

Type: Promise.<Object>

matchEndpoint()

Request routing and validation

Source:

zpt/api/NavigationEndpoint.js, line 601

matchesFilters(properties, filters) → {boolean}

Check if properties match specified filters

Parameters:

Name	Type	Description
`properties`	Object	Entity properties
`filters`	Object	Filter criteria

Source:

ragno/algorithms/Hyde.js, line 565

Returns:

Whether properties match filters

Type: boolean

(async) memorize(text, options) → {Object}

Main method to ingest text into memory system

Parameters:

Name	Type	Description
`text`	string	Text content to memorize
`options`	Object	Processing options

Source:

ragno/Memorise.js, line 280

Returns:

Processing results and statistics

Type: Object

mergeSmallChunks()

Merge small consecutive chunks

Source:

zpt/transform/ContentChunker.js, line 813

(async) migrate()

Execute complete data migration pipeline

Source:

migration/DataMigration.js, line 51

(async) migrateDocument()

Migrate individual document with proper ragno structure

Source:

migration/DataMigration.js, line 173

(async) migrateDocuments()

Migrate document data from source to target content graph

Source:

migration/DataMigration.js, line 134

migrateExistingSystem()

Migration utilities

Source:

prompts/index.js, line 185

migrateMCPRegistry()

Migrate MCP prompt registry

Source:

prompts/migrate-existing.js, line 143

(async) migrateNavigation()

Migrate navigation data to proper ZPT structure

Source:

migration/DataMigration.js, line 302

migratePromptTemplates()

Migrate existing PromptTemplates.js to unified system

Source:

prompts/migrate-existing.js, line 15

(async) navigate()

Main navigation operation

Source:

api/features/ZptAPI.js, line 262

normalize(params) → {Object}

Normalize complete parameter object

Parameters:

Name	Type	Description
`params`	Object	Raw navigation parameters

Source:

zpt/parameters/ParameterNormalizer.js, line 30

Returns:

Normalized parameters

Type: Object

normalizeContent()

Normalize content input to a standard format

Source:

zpt/transform/ContentChunker.js, line 164

normalizeCoordinates(x, y) → {Array}

Normalize coordinates according to boundary conditions

Parameters:

Name	Type	Description
`x`	number	X coordinate
`y`	number	Y coordinate

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 206

Returns:

Normalized coordinates [x, y]

Type: Array

normalizeEntityFilter()

Normalize entity filter

Source:

zpt/parameters/ParameterNormalizer.js, line 146

normalizeError()

Normalize error into standard format

Source:

zpt/api/ErrorHandler.js, line 255

normalizeGeographicFilter()

Normalize geographic filter

Source:

zpt/parameters/ParameterNormalizer.js, line 186

normalizeMinMax()

Min-max normalization

Source:

ragno/search/SearchFilters.js, line 501

normalizePan()

Normalize pan parameter with filters

Source:

zpt/parameters/ParameterNormalizer.js, line 72

normalizePath()

Utility methods

Source:

zpt/api/RequestParser.js, line 594

normalizeScoreArray()

Normalize array of scores

Source:

ragno/search/SearchFilters.js, line 483

(async) normalizeScores()

Normalize scores across results

Source:

ragno/search/SearchFilters.js, line 278

normalizeSigmoid()

Sigmoid normalization

Source:

ragno/search/SearchFilters.js, line 531

normalizeTemplate()

Normalize various input formats to standard interfaces

Source:

prompts/PromptManager.js, line 364

normalizeTemporalFilter()

Normalize temporal filter

Source:

zpt/parameters/ParameterNormalizer.js, line 159

normalizeTilt()

Normalize tilt parameter

Source:

zpt/parameters/ParameterNormalizer.js, line 93

normalizeTopicFilter()

Normalize topic filter

Source:

zpt/parameters/ParameterNormalizer.js, line 133

normalizeTransform()

Normalize transform parameter with defaults

Source:

zpt/parameters/ParameterNormalizer.js, line 108

normalizeZScore()

Z-score normalization

Source:

ragno/search/SearchFilters.js, line 516

normalizeZoom()

Normalize zoom parameter

Source:

zpt/parameters/ParameterNormalizer.js, line 57

offsetToCube(col, row) → {Object}

Convert offset coordinates to cube coordinates (for hexagonal topology)

Parameters:

Name	Type	Description
`col`	number	Column (x coordinate)
`row`	number	Row (y coordinate)

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 128

Returns:

Cube coordinates {x, y, z}

Type: Object

optimizeCriteria()

Optimize criteria for performance

Source:

zpt/parameters/SelectionCriteria.js, line 535

optimizeIndex(optionsopt)

Optimize index performance

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Optimization options

Source:

ragno/search/VectorIndex.js, line 470

optimizeTokenUsage(content, tokenBudget, strategy) → {Object}

Optimize token usage for a given budget

Parameters:

Name	Type	Default	Description
`content`	Array.<Object>		Content items with token counts
`tokenBudget`	number		Available token budget
`strategy`	string	priority	Optimization strategy

Source:

zpt/transform/TokenCounter.js, line 433

Returns:

Optimization result

Type: Object

optimizeVectorIndex(optionsopt)

Optimize vector index

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Optimization options

Source:

ragno/search/index.js, line 494

(async) parse(req) → {Promise.<Object>}

Main parsing method - extracts and normalizes request data

Parameters:

Name	Type	Description
`req`	Object	HTTP request object

Source:

zpt/api/RequestParser.js, line 44

Returns:

Parsed request data

Type: Promise.<Object>

(async) parseBody()

Parse request body based on content type

Source:

zpt/api/RequestParser.js, line 226

(async) parseComponents()

Parse all request components

Source:

zpt/api/RequestParser.js, line 136

parseCookies()

Parse cookies from header

Source:

zpt/api/RequestParser.js, line 410

parseEntityExtractionResponse(response) → {Array}

Parse LLM response for extracted entities

Parameters:

Name	Type	Description
`response`	string	LLM response

Source:

ragno/search/DualSearch.js, line 498

Returns:

Extracted entity names

Type: Array

parseFormBody()

Parse form-encoded body

Source:

zpt/api/RequestParser.js, line 311

parseHeaders()

Parse request headers

Source:

zpt/api/RequestParser.js, line 165

parseJsonBody()

Parse JSON body

Source:

zpt/api/RequestParser.js, line 293

parseJsonResponse(responseText) → {Object}

Attempt to parse JSON with syntax resolution

This is a convenience method that combines resolveSyntax with JSON.parse and provides detailed error information.

Attempt to parse JSON with syntax resolution

This is a convenience method that combines resolveSyntax with JSON.parse and provides detailed error information.

Parameters:

Name	Type	Description
`responseText`	string	Raw LLM response text

Source:

utils/ParseHelper.js, line 167

Returns:

{success: boolean, data?: any, error?: string, cleaned?: string}

Type: Object

parseMultipartBody()

Parse multipart form data (simplified implementation)

Source:

zpt/api/RequestParser.js, line 336

parseMultipartPart()

Parse individual multipart part

Source:

zpt/api/RequestParser.js, line 374

parseQueryParams()

Parse query parameters from URL

Source:

zpt/api/RequestParser.js, line 197

parseQueryResults()

Parse SPARQL query results into corpuscle objects

Source:

zpt/selection/CorpuscleSelector.js, line 378

(async) performClustering()

Perform clustering on the SOM

Source:

api/features/VSOMAPI.js, line 335

(async) performExactMatch(queryData, options) → {Array}

Perform exact matching via SPARQL

Parameters:

Name	Type	Description
`queryData`	Object	Processed query data
`options`	Object	Search options

Source:

ragno/search/DualSearch.js, line 218

Returns:

Exact match results

Type: Array

(async) performHealthCheck()

Perform a health check with timeout

Source:

zpt/api/NavigationEndpoint.js, line 826

(async) performPPRTraversal(queryEntities, options) → {Object}

Perform PPR traversal for graph-based discovery

Parameters:

Name	Type	Description
`queryEntities`	Array	Starting entity names or URIs
`options`	Object	Traversal options

Source:

ragno/search/DualSearch.js, line 323

Returns:

PPR traversal results

Type: Object

(async) performQuickRecall()

Perform quick recall with predefined query and domain

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 483

(async) performVectorSimilarity(queryData, options) → {Array}

Perform vector similarity search

Parameters:

Name	Type	Description
`queryData`	Object	Processed query data
`options`	Object	Search options

Source:

ragno/search/DualSearch.js, line 267

Returns:

Vector similarity results

Type: Array

populateSettingsFromConfig()

Populate settings form from server config

Source:

frontend/js/components/_settings.js, line 220

(async) populateVectorIndexFromSPARQL()

Populate vector index from SPARQL store

Source:

ragno/search/index.js, line 374

postProcessChunks()

Post-process chunks for optimization

Source:

zpt/transform/ContentChunker.js, line 731

(async) postProcessCorpuscles()

Post-process selected corpuscles

Source:

zpt/selection/CorpuscleSelector.js, line 772

(async) preciseTokenCount(text, tokenizerName) → {Promise.<Object>}

Precise token counting using actual tokenizer

Parameters:

Name	Type	Description
`text`	string	Text to tokenize
`tokenizerName`	string	Tokenizer to use

Source:

zpt/transform/TokenCounter.js, line 162

Returns:

Precise token count

Type: Promise.<Object>

(async) preloadTemplates() → {Promise.<void>}

Preload all available templates

Source:

aux/wikidata/QueryTemplateManager.js, line 311

Returns:

Type: Promise.<void>

(async) preview()

Navigation preview (limited processing)

Source:

api/features/ZptAPI.js, line 307

(async) process() → {Promise.<Object>}

Main process - find units without corpuscles and create them

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 160

Returns:

Processing results

Type: Promise.<Object>

(async) processBatch(batch) → {Promise.<Object>}

Process a batch of units

Parameters:

Name	Type	Description
`batch`	Array	Batch of units to process

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 316

Returns:

Batch processing result

Type: Promise.<Object>

(async) processConcepts()

Process concept operations in batch

Source:

stores/RagnoMemoryStore.js, line 109

(async) processEntityData()

Process entity data format

Source:

api/features/VSOMAPI.js, line 428

(async) processIterations(input, resources, options) → {Promise.<Object>}

Process iterative feedback loops for comprehensive question answering

Parameters:

Name Type Description

input

Object

Iteration input data

Properties

Name	Type	Description
`originalQuestion`	Object	Original question object with uri and text
`initialResponse`	string	Initial response to analyze and improve
`context`	string	Available context for the question

resources

Object

External dependencies

Properties

Name	Type	Description
`llmHandler`	Object	LLM handler for analysis and generation
`sparqlHelper`	Object	SPARQL helper for database operations
`config`	Object	Configuration object with graph URIs
`wikidataResearch`	Object	Wikidata research component (optional)

options

Object

Configuration options

Properties

Name	Type	Description
`maxIterations`	number	Maximum iterations to perform (default: 3)
`completenessThreshold`	number	Threshold for completeness (default: 0.8)
`maxFollowUpQuestions`	number	Max follow-up questions per iteration (default: 2)

Source:

compose/feedback/IterationManager.js, line 39

Returns:

Complete iteration results with final answer

Type: Promise.<Object>

(async) processQuery(input, llmHandler, targetDataset, options) → {Object}

Process a single query or input to generate hypotheses

Parameters:

Name	Type	Description
`input`	string	Query string or entity URI
`llmHandler`	Object	LLM handler instance
`targetDataset`	Dataset	RDF dataset to augment
`options`	Object	Processing options

Source:

ragno/algorithms/Hyde.js, line 131

Returns:

Processing results

Type: Object

(async) processQuery(query, options) → {Object}

Process natural language query to extract entities and generate embeddings

Parameters:

Name	Type	Description
`query`	string	Original query string
`options`	Object	Processing options

Source:

ragno/search/DualSearch.js, line 156

Returns:

Processed query data

Type: Object

(async) processRelationships()

Process relationship operations in batch

Source:

stores/RagnoMemoryStore.js, line 144

processResults(graph, scores, entryPoints, options) → {Object}

Process PPR results and generate rankings

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`scores`	Map	PPR probability scores
`entryPoints`	Array	Original entry points
`options`	Object	Algorithm options

Source:

ragno/algorithms/PersonalizedPageRank.js, line 251

Returns:

Processed results

Type: Object

processSPARQLResults(sparqlResults) → {Array}

Process SPARQL results into entity format

Parameters:

Name	Type	Description
`sparqlResults`	Array	SPARQL query results

Source:

ragno/algorithms/VSOM.js, line 566

Returns:

Processed entities

Type: Array

(async) processSparqlData()

Process SPARQL data format

Source:

api/features/VSOMAPI.js, line 474

(async) processUnitsInBatches(units) → {Promise.<Object>}

Process units in batches

Parameters:

Name	Type	Description
`units`	Array	Array of unit data

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 281

Returns:

Batch processing results

Type: Promise.<Object>

(async) project(corpuscles, tiltParams, context) → {Promise.<Object>}

Main projection method - transforms corpuscles based on tilt representation

Parameters:

Name	Type	Description
`corpuscles`	Array	Selected corpuscles to transform
`tiltParams`	Object	Normalized tilt parameters
`context`	Object	Projection context and dependencies

Source:

zpt/selection/TiltProjector.js, line 144

Returns:

Projected representation

Type: Promise.<Object>

(async) projectToConcepts()

Project corpuscles to concept representation using RDF-based concept extraction

Source:

zpt/selection/TiltProjector.js, line 907

(async) projectToEmbedding()

Project corpuscles to embedding representation

Source:

zpt/selection/TiltProjector.js, line 185

(async) projectToGraph()

Project corpuscles to graph representation

Source:

zpt/selection/TiltProjector.js, line 298

(async) projectToKeywords()

Project corpuscles to keyword representation

Source:

zpt/selection/TiltProjector.js, line 237

(async) projectToTemporal()

Project corpuscles to temporal representation

Source:

zpt/selection/TiltProjector.js, line 366

pruneContext()

Remove old or low-relevance items from context

Source:

ContextManager.js, line 61

query(subjectopt, predicateopt, objectopt) → {Array}

Query the dataset using SPARQL-like patterns

Parameters:

Name	Type	Attributes	Default	Description
`subject`	NamedNode	<optional>	null	Subject pattern (null for any)
`predicate`	NamedNode	<optional>	null	Predicate pattern (null for any)
`object`	NamedNode \| Literal	<optional>	null	Object pattern (null for any)

Source:

ragno/core/RDFGraphManager.js, line 217

Returns:

Array of matching quads

Type: Array

(async) queryByZoomLevel(queryConfig) → {Promise.<Array>}

Execute ZPT query by zoom level with filters

Parameters:

Name	Type	Description
`queryConfig`	Object	Configuration with zoomLevel, filters, limit

Source:

stores/SPARQLStore.js, line 865

Returns:

Query results

Type: Promise.<Array>

(async) queryConceptsByFilter()

Query concepts by category, confidence, or relationships

Source:

stores/SPARQLStore.js, line 1444

(async) queryCorpuscles(limit) → {Promise.<Object>}

Query generated corpuscles for verification

Parameters:

Name	Type	Default	Description
`limit`	number	10	Maximum number of results to return

Source:

aux/wikipedia/UnitsToCorpuscles.js, line 513

Returns:

Query results

Type: Promise.<Object>

(async) queryDocumentChunks(documentUri, options) → {Promise.<Array>}

Query chunks for a specific document

Parameters:

Name	Type	Description
`documentUri`	string	Document URI
`options`	Object	Query options

Source:

services/document/Ingester.js, line 412

Returns:

Query results

Type: Promise.<Array>

(async) queryDocuments(options) → {Promise.<Array>}

Query ingested documents

Parameters:

Name	Type	Description
`options`	Object	Query options

Source:

services/document/Ingester.js, line 379

Returns:

Query results

Type: Promise.<Array>

(async) queryHypotheses()

Query hypothetical content from the knowledge graph

Source:

api/features/RagnoAPI.js, line 658

queryHypotheticalContent(dataset, filtersopt) → {Array}

Query hypothetical content from RDF dataset

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF dataset to query
`filters`	Object	<optional>	Query filters

Source:

ragno/algorithms/Hyde.js, line 524

Returns:

Hypothetical content matching filters

Type: Array

queryHypotheticalContent(dataset, filtersopt) → {Array}

Query hypothetical content from dataset

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF dataset to query
`filters`	Object	<optional>	Query filters

Source:

ragno/algorithms/index.js, line 395

Returns:

Hypothetical content matching filters

Type: Array

(async) queryUnits(limit) → {Promise.<Object>}

Query loaded Wikipedia units for verification

Parameters:

Name	Type	Default	Description
`limit`	number	10	Maximum number of results to return

Source:

aux/wikipedia/Search.js, line 409

Returns:

Query results

Type: Promise.<Object>

queueSync()

Queue a sync operation for batch processing

Source:

stores/RagnoMemoryStore.js, line 58

quickStart()

Quick start function for common use cases

Source:

prompts/index.js, line 105

rankByScore()

Rank by raw score

Source:

ragno/search/SearchFilters.js, line 422

(async) rankBySimilarity()

Rank corpuscles by embedding similarity

Source:

zpt/selection/CorpuscleSelector.js, line 458

rankByType()

Rank by type priority

Source:

ragno/search/SearchFilters.js, line 433

rankByWeightedScore()

Rank by weighted score

Source:

ragno/search/SearchFilters.js, line 406

rankHybrid()

Hybrid ranking (type + score)

Source:

ragno/search/SearchFilters.js, line 452

(async) readRawBody()

Read raw body data from request stream

Source:

zpt/api/RequestParser.js, line 256

recordIteration(iteration, learningRate, neighborhoodRadius, results)

Record iteration results

Parameters:

Name	Type	Description
`iteration`	number	Current iteration
`learningRate`	number	Learning rate used
`neighborhoodRadius`	number	Neighborhood radius used
`results`	Object	Iteration results

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 336

(async) recoverFromValidationError()

Recovery strategy implementations

Source:

zpt/api/ErrorHandler.js, line 369

recursive(validator, options)

Create a recursive validator for nested structures

Parameters:

Name	Type	Description
`validator`	string \| Object	Base validator
`options`	Object	Recursion options

Source:

api/common/CustomValidators.js, line 197

refinementPhase(graph, nodeToCommId, options) → {Object}

Refinement phase to ensure well-connected communities

Parameters:

Name	Type	Description
`graph`	Object	Graph representation
`nodeToCommId`	Map	Current node to community mapping
`options`	Object	Algorithm options

Source:

ragno/algorithms/CommunityDetection.js, line 228

Returns:

Refined node to community mapping

Type: Object

(async) register()

Source:

api/common/APIRegistry.js, line 21

register(name, validator)

Parameters:

Name	Type	Description
`name`	string	Validator name
`validator`	Object	Validator definition

Source:

api/common/CustomValidators.js, line 80

registerBatch(validators)

Parameters:

Name	Type	Description
`validators`	Object	Map of validator names to definitions

Source:

api/common/CustomValidators.js, line 95

registerTemplate(name, template) → {boolean}

Parameters:

Name Type Description

name

string

Template name

template

Object

Template definition

Properties

Name	Type	Description
`query`	string	Query template with placeholders
`prefixes`	Array.<string>	Required prefixes
`parameters`	Array.<string>	Required parameters
`description`	string	Template description

Source:

compose/sparql/TemplateManager.js, line 113

Returns:

Success status

Type: boolean

registerTemplate()

Source:

prompts/PromptManager.js, line 104

(async) reloadExternalTemplates()

Reload all external templates (useful for development)

Source:

prompts/PromptManager.js, line 609

removeNamespace(prefix)

Remove a namespace

Parameters:

Name	Type	Description
`prefix`	string	Namespace prefix to remove

Source:

ragno/core/NamespaceManager.js, line 417

removeNode(uri) → {boolean}

Remove a node from the index

Parameters:

Name	Type	Description
`uri`	string	URI of the node to remove

Source:

ragno/search/VectorIndex.js, line 294

Returns:

True if node was removed

Type: boolean

removeNodeFromIndex(uri) → {boolean}

Remove node from vector index

Parameters:

Name	Type	Description
`uri`	string	Node URI

Source:

ragno/search/index.js, line 266

Returns:

True if removed

Type: boolean

removeTriple(predicate, objectopt)

Remove a triple from the dataset

Parameters:

Name	Type	Attributes	Default	Description
`predicate`	NamedNode			Predicate
`object`	NamedNode \| Literal	<optional>	null	Object (optional for removing all)

Source:

ragno/models/RDFElement.js, line 86

(async) researchConcepts(input, resources, options) → {Promise.<Object>}

Research concepts using Wikidata

Parameters:

Name Type Description

input

Object

Research input

Properties

Name	Type	Description
`question`	string	Question to research
`concepts`	Array.<string>	Pre-extracted concepts (optional)

resources

Object

Required resources (llmHandler, sparqlHelper, config)

options

Object

Research options

Source:

aux/ResearchService.js, line 68

Returns:

Research results

Type: Promise.<Object>

reset()

Reset VSOM state

Source:

ragno/algorithms/VSOM.js, line 840

reset()

Reset training state

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 476

reset()

Clear cache and reset metrics

Source:

zpt/selection/CorpuscleSelector.js, line 935

resetStatistics()

Reset algorithm statistics

Source:

ragno/algorithms/Hyde.js, line 596

resetStatistics()

Reset all statistics

Source:

ragno/algorithms/index.js, line 464

resetStatistics()

Reset algorithm statistics

Source:

ragno/algorithms/vsom/VSOMCore.js, line 460

resetStatistics()

Reset statistics

Source:

ragno/search/SearchFilters.js, line 594

resetStats()

Reset statistics

Source:

aux/ResearchService.js, line 341

resetStats()

Reset statistics

Source:

aux/wikidata/WikidataConnector.js, line 364

resetStats()

Reset statistics

Source:

aux/wikidata/WikidataSearch.js, line 467

resetStats()

Reset statistics

Source:

aux/wikidata/WikidataToRagno.js, line 465

resetStats()

Reset statistics

Source:

zpt/transform/ContentChunker.js, line 1067

resolve(prefixedName) → {string}

Resolve a prefixed name to full URI

Parameters:

Name	Type	Description
`prefixedName`	string	Name like "ragno:Entity"

Source:

ragno/core/NamespaceManager.js, line 257

Returns:

Full URI

Type: string

(async) resolveEntityNamesToURIs(entityNames) → {Array}

Resolve entity names to URIs by searching the knowledge graph

Parameters:

Name	Type	Description
`entityNames`	Array	Entity names to resolve

Source:

ragno/search/DualSearch.js, line 687

Returns:

Array of entity URIs found in the knowledge graph

Type: Array

resolveSyntax(responseText) → {string|false}

Resolve and clean JSON syntax from LLM responses

This method handles common patterns where LLMs wrap JSON in markdown code fences or add explanatory text around the JSON content.

Resolve and clean JSON syntax from LLM responses

This method handles common patterns where LLMs wrap JSON in markdown code fences or add explanatory text around the JSON content.

Parameters:

Name	Type	Description
`responseText`	string	Raw LLM response text

Source:

utils/ParseHelper.js, line 19

Returns:

Cleaned JSON string if pattern matches, false otherwise

Type: string | false

(async) restoreFromBackup()

Restore from backup in case of failure

Source:

migration/DataMigration.js, line 408

(async, abstract) retrieveInteractions(query)

Retrieve interactions

Parameters:

Name	Type	Description
`query`	Object	Query parameters

Source:

api/common/BaseAPI.js, line 62

(async) retrieveInteractions()

Retrieve interactions from memory

Source:

api/features/MemoryAPI.js, line 121

(async) retrieveInteractions()

Retrieve interactions (inherited from BaseAPI)

Source:

api/features/RagnoAPI.js, line 822

(async) retrieveInteractions()

Retrieve interactions (inherited from BaseAPI)

Source:

api/features/UnifiedSearchAPI.js, line 722

(async) retrieveInteractions()

Retrieve interactions (inherited from BaseAPI)

Source:

api/features/ZptAPI.js, line 609

runDeepPPR(graph, entryPoints, optionsopt) → {Object}

Run deep PPR for comprehensive traversal

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation
`entryPoints`	Array		Entry point node URIs
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/PersonalizedPageRank.js, line 196

Returns:

Deep PPR results

Type: Object

(async) runEntityClustering(entities, embeddingHandler, optionsopt) → {Promise.<Object>}

Run entity clustering using VSOM

Parameters:

Name	Type	Attributes	Description
`entities`	Array		Array of entities to cluster
`embeddingHandler`	Object		Embedding handler for vector generation
`options`	Object	<optional>	VSOM options

Source:

ragno/algorithms/index.js, line 406

Returns:

Clustering results

Type: Promise.<Object>

(async) runFullAnalysis(dataset, optionsopt) → {Object}

Run complete graph analysis pipeline

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF-Ext dataset
`options`	Object	<optional>	Analysis options

Source:

ragno/algorithms/index.js, line 78

Returns:

Complete analysis results

Type: Object

runFullMigration()

Full migration process

Source:

prompts/migrate-existing.js, line 292

(async) runFullPipeline()

Run full ragno pipeline

Source:

api/features/RagnoAPI.js, line 554

(async) runHydeGeneration(inputs, llmHandler, targetDataset, optionsopt) → {Object}

Run HyDE hypothesis generation

Parameters:

Name	Type	Attributes	Description
`inputs`	Array \| string		Query strings or entity URIs
`llmHandler`	Object		LLM handler instance
`targetDataset`	Dataset		RDF dataset to augment
`options`	Object	<optional>	Hyde options

Source:

ragno/algorithms/index.js, line 382

Returns:

Hyde generation results

Type: Object

runPPR(graph, entryPoints, optionsopt) → {Object}

Run Personalized PageRank from entry points

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation from GraphAnalytics
`entryPoints`	Array		Array of entry point node URIs
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/PersonalizedPageRank.js, line 52

Returns:

PPR results with scores and rankings

Type: Object

(async) runSemanticSearch(dataset, queryEntities, optionsopt) → {Object}

Run semantic search using PPR

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF-Ext dataset
`queryEntities`	Array		Entity URIs to start search from
`options`	Object	<optional>	Search options

Source:

ragno/algorithms/index.js, line 169

Returns:

Search results with ranked nodes

Type: Object

runShallowPPR(graph, entryPoints, optionsopt) → {Object}

Run shallow PPR for quick traversal (2-3 iterations)

Parameters:

Name	Type	Attributes	Description
`graph`	Object		Graph representation
`entryPoints`	Array		Entry point node URIs
`options`	Object	<optional>	Algorithm options

Source:

ragno/algorithms/PersonalizedPageRank.js, line 181

Returns:

Shallow PPR results

Type: Object

(async) runTargetedAnalysis(dataset, algorithms, optionsopt) → {Object}

Run targeted analysis for specific algorithms

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF-Ext dataset
`algorithms`	Array		Array of algorithm names
`options`	Object	<optional>	Analysis options

Source:

ragno/algorithms/index.js, line 239

Returns:

Targeted analysis results

Type: Object

(async) runVSOMAnalysis(dataset, embeddingHandler, optionsopt) → {Promise.<Object>}

Run VSOM analysis on dataset

Parameters:

Name	Type	Attributes	Description
`dataset`	Dataset		RDF dataset containing entities
`embeddingHandler`	Object		Embedding handler for vector generation
`options`	Object	<optional>	Analysis options

Source:

ragno/algorithms/index.js, line 436

Returns:

VSOM analysis results

Type: Promise.<Object>

sanitizeData()

Utility methods

Source:

zpt/api/ResponseFormatter.js, line 580

sanitizeErrorMessage()

Utility methods

Source:

zpt/api/ErrorHandler.js, line 554

(async) saveIndex(indexPath, metadataPath)

Save index to file

Parameters:

Name	Type	Description
`indexPath`	string	Path to save HNSW index
`metadataPath`	string	Path to save metadata

Source:

ragno/search/VectorIndex.js, line 362

(async) saveVectorIndex()

Save vector index to disk

Source:

ragno/search/index.js, line 323

scoreByGraph()

Score corpuscles by graph connectivity

Source:

zpt/selection/CorpuscleSelector.js, line 521

scoreByKeywords()

Score corpuscles by keyword relevance

Source:

zpt/selection/CorpuscleSelector.js, line 484

(async) search(queryText, options) → {Promise.<Object>}

Search Wikipedia using the API

Parameters:

Name	Type	Description
`queryText`	string	Search query text
`options`	Object	Search options

Source:

aux/wikipedia/Search.js, line 69

Returns:

Search results with query metadata

Type: Promise.<Object>

(async) search(query, optionsopt) → {Object}

Main dual search interface

Parameters:

Name	Type	Attributes	Description
`query`	string		Natural language search query
`options`	Object	<optional>	Search options

Source:

ragno/search/DualSearch.js, line 93

Returns:

Combined search results

Type: Object

search(queryEmbedding, kopt, optionsopt) → {Array}

Search for similar nodes

Parameters:

Name	Type	Attributes	Default	Description
`queryEmbedding`	Array.<number>			Query vector
`k`	number	<optional>	10	Number of results to return
`options`	Object	<optional>		Search options

Source:

ragno/search/VectorIndex.js, line 138

Returns:

Search results with scores and metadata

Type: Array

(async) search(query, optionsopt) → {Object}

Main search interface

Parameters:

Name	Type	Attributes	Description
`query`	string		Search query
`options`	Object	<optional>	Search options

Source:

ragno/search/index.js, line 179

Returns:

Search results

Type: Object

(async) search(queryEmbedding, limit, threshold) → {Array.<Object>}

Search for similar items using basic string matching

Parameters:

Name	Type	Description
`queryEmbedding`	Array.<number>	Query embedding vector
`limit`	number	Maximum number of results
`threshold`	number	Similarity threshold (not used in this basic implementation)

Source:

stores/SPARQLStore.js, line 1505

Returns:

Search results

Type: Array.<Object>

(async) searchByConcepts(concepts, options) → {Promise.<Object>}

Search for entities by extracted concepts

Parameters:

Name	Type	Description
`concepts`	Array.<Object>	Concept objects with value, type, confidence
`options`	Object	Search options

Source:

aux/wikidata/WikidataSearch.js, line 158

Returns:

Concept-to-entity mappings

Type: Promise.<Object>

(async) searchByText(searchTerms, options) → {Promise.<Object>}

Search for entities by text with advanced filtering

Parameters:

Name	Type	Description
`searchTerms`	string \| Array.<string>	Text to search for
`options`	Object	Search options

Source:

aux/wikidata/WikidataSearch.js, line 52

Returns:

Search results with ranked entities

Type: Promise.<Object>

searchByTypes(queryEmbedding, types, kopt) → {Object}

Search within specific ragno types

Parameters:

Name	Type	Attributes	Default	Description
`queryEmbedding`	Array.<number>			Query vector
`types`	Array.<string>			Ragno types to search within
`k`	number	<optional>	10	Number of results per type

Source:

ragno/search/VectorIndex.js, line 213

Returns:

Results grouped by type

Type: Object

(async) searchByWikipediaTitle(titles, options) → {Promise.<Object>}

Search for entities by Wikipedia article titles

Parameters:

Name	Type	Description
`titles`	string \| Array.<string>	Wikipedia article titles
`options`	Object	Search options

Source:

aux/wikidata/WikidataSearch.js, line 107

Returns:

Matching Wikidata entities

Type: Promise.<Object>

(async) searchContent()

Search content using semantic similarity

Source:

api/features/SearchAPI.js, line 78

(async) searchExact(query, optionsopt) → {Array}

Exact match search only

Parameters:

Name	Type	Attributes	Description
`query`	string		Search query
`options`	Object	<optional>	Search options

Source:

ragno/search/index.js, line 198

Returns:

Exact match results

Type: Array

(async) searchGraph()

Search the knowledge graph

Source:

api/features/RagnoAPI.js, line 358

(async) searchSimilarity(query, optionsopt) → {Array}

Vector similarity search only

Parameters:

Name	Type	Attributes	Description
`query`	string		Search query
`options`	Object	<optional>	Search options

Source:

ragno/search/index.js, line 211

Returns:

Vector similarity results

Type: Array

(async) searchTraversal(entityUris, optionsopt) → {Object}

PPR traversal search

Parameters:

Name	Type	Attributes	Description
`entityUris`	Array		Starting entity URIs
`options`	Object	<optional>	Traversal options

Source:

ragno/search/index.js, line 224

Returns:

PPR traversal results

Type: Object

(async) searchWikipedia(query, options) → {Promise.<Object>}

Search Wikipedia articles

Parameters:

Name	Type	Description
`query`	string	Search query
`options`	Object	Search options

Source:

aux/ResearchService.js, line 97

Returns:

Search results

Type: Promise.<Object>

seededRandom(seed) → {function}

Seeded random number generator for reproducible results

Parameters:

Name	Type	Description
`seed`	number	Random seed

Source:

ragno/algorithms/CommunityDetection.js, line 70

Returns:

Random number generator function

Type: function

(async) select(params) → {Promise.<Object>}

Main selection method - selects corpuscles based on ZPT parameters

Parameters:

Name	Type	Description
`params`	Object	Raw ZPT navigation parameters

Source:

zpt/selection/CorpuscleSelector.js, line 71

Returns:

Selection results with corpuscles and metadata

Type: Promise.<Object>

(async) selectByEmbedding()

Select corpuscles using embedding similarity

Source:

zpt/selection/CorpuscleSelector.js, line 289

(async) selectByGraph()

Select corpuscles using graph structure

Source:

zpt/selection/CorpuscleSelector.js, line 328

(async) selectByKeywords()

Select corpuscles using keyword matching

Source:

zpt/selection/CorpuscleSelector.js, line 317

(async) selectByTemporal()

Select corpuscles using temporal ordering

Source:

zpt/selection/CorpuscleSelector.js, line 339

(async) selectEnhanced(params) → {Promise.<Object>}

Enhanced selection method using live SPARQL filtering

Parameters:

Name	Type	Description
`params`	Object	ZPT navigation parameters

Source:

zpt/selection/CorpuscleSelector.js, line 172

Returns:

Enhanced selection results

Type: Promise.<Object>

selectOptimalStrategy()

Select optimal chunking strategy based on content analysis

Source:

zpt/transform/ContentChunker.js, line 194

(async) semanticChunking()

Semantic boundary chunking strategy

Source:

zpt/transform/ContentChunker.js, line 262

sendError(res, status, message, detailopt)

Send error response

Parameters:

Name	Type	Attributes	Default	Description
`res`	Object			Express response object
`status`	number			HTTP status code
`message`	string			Error message
`detail`	string	<optional>	null	Error detail

Source:

ragno/search/SearchAPI.js, line 556

sendSuccess(res, data)

Send successful response

Parameters:

Name	Type	Description
`res`	Object	Express response object
`data`	Object	Response data

Source:

ragno/search/SearchAPI.js, line 536

setAllMetadata(metadata)

Set multiple metadata properties at once

Parameters:

Name	Type	Description
`metadata`	Object	Object with property/value pairs

Source:

ragno/models/RDFElement.js, line 522

setCategory(category)

Set the attribute category/type (more specific than subType)

Parameters:

Name	Type	Description
`category`	string	Attribute category

Source:

ragno/Attribute.js, line 163

setConfidence(confidence)

Set confidence score for this attribute

Parameters:

Name	Type	Description
`confidence`	number	Confidence score (0-1)

Source:

ragno/Attribute.js, line 145

setContent(content)

Set content for this element

Parameters:

Name	Type	Description
`content`	string	Text content

Source:

ragno/models/RDFElement.js, line 106

setCorpus(corpus)

Set corpus association for this attribute

Parameters:

Name	Type	Description
`corpus`	string \| NamedNode	Corpus URI or node

Source:

ragno/Attribute.js, line 203

setCorpus(corpus)

Set corpus association for this entity

Parameters:

Name	Type	Description
`corpus`	string \| NamedNode	Corpus URI or node

Source:

ragno/Entity.js, line 118

setCorpus(corpus)

Set corpus association for this unit

Parameters:

Name	Type	Description
`corpus`	string \| NamedNode	Corpus URI or node

Source:

ragno/SemanticUnit.js, line 271

setEmbedding(embedding)

Set vector embedding for this unit

Parameters:

Name	Type	Description
`embedding`	Array.<number>	Vector embedding

Source:

ragno/SemanticUnit.js, line 168

setEmbeddingHandler(embeddingHandler)

Set embedding handler for vector generation

Parameters:

Name	Type	Description
`embeddingHandler`	Object	Embedding handler instance

Source:

ragno/search/DualSearch.js, line 828

setEmbeddingHandler(embeddingHandler)

Set embedding handler

Parameters:

Name	Type	Description
`embeddingHandler`	Object	Embedding handler instance

Source:

ragno/search/SearchAPI.js, line 648

setEmbeddingHandler(embeddingHandler)

Set embedding handler

Parameters:

Name	Type	Description
`embeddingHandler`	Object	Embedding handler instance

Source:

ragno/search/index.js, line 601

setEntity(entity)

Set the entity this attribute describes

Parameters:

Name	Type	Description
`entity`	Entity \| NamedNode \| string	Entity reference

Source:

ragno/Attribute.js, line 108

setEntryPoint(isEntryPoint)

Set whether this element is an entry point

Parameters:

Name	Type	Description
`isEntryPoint`	boolean	Entry point status

Source:

ragno/models/RDFElement.js, line 152

setFirstSeen(timestamp)

Set first seen timestamp

Parameters:

Name	Type	Description
`timestamp`	Date \| string	First seen date

Source:

ragno/Entity.js, line 137

setFrequency(frequency)

Set frequency for this entity (usage tracking)

Parameters:

Name	Type	Description
`frequency`	number	Frequency count

Source:

ragno/Entity.js, line 91

setLLMHandler(llmHandler)

Set LLM handler for entity extraction

Parameters:

Name	Type	Description
`llmHandler`	Object	LLM handler instance

Source:

ragno/search/DualSearch.js, line 819

setLLMHandler(llmHandler)

Set LLM handler

Parameters:

Name	Type	Description
`llmHandler`	Object	LLM handler instance

Source:

ragno/search/SearchAPI.js, line 639

setLLMHandler(llmHandler)

Set LLM handler

Parameters:

Name	Type	Description
`llmHandler`	Object	LLM handler instance

Source:

ragno/search/index.js, line 584

setLanguage(language)

Set language for this attribute

Parameters:

Name	Type	Description
`language`	string	Language code (e.g., 'en', 'es')

Source:

ragno/Attribute.js, line 240

setLanguage(language)

Set language for this unit

Parameters:

Name	Type	Description
`language`	string	Language code (e.g., 'en', 'es')

Source:

ragno/SemanticUnit.js, line 290

setLastAccessed(timestamp)

Set last accessed timestamp

Parameters:

Name	Type	Description
`timestamp`	Date \| string	Last accessed date

Source:

ragno/Entity.js, line 159

setLength(length)

Set length of this unit in characters

Parameters:

Name	Type	Description
`length`	number	Character length

Source:

ragno/SemanticUnit.js, line 150

setMetadataProperty(property, value)

Set a metadata property as an RDF triple

Parameters:

Name	Type	Description
`property`	string	Property name
`value`	any	Property value

Source:

ragno/models/RDFElement.js, line 386

setName(name, langopt)

Set the name/label for this entity

Parameters:

Name	Type	Attributes	Default	Description
`name`	string			Entity name
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/Entity.js, line 65

setNodeWeights(nodeIndex, weights)

Set weight vector for a specific map node

Parameters:

Name	Type	Description
`nodeIndex`	number	Index of the map node
`weights`	Array	New weight vector

Source:

ragno/algorithms/vsom/VSOMCore.js, line 417

setPPRScore(score)

Set PPR score for this element

Parameters:

Name	Type	Description
`score`	number	PPR score

Source:

ragno/models/RDFElement.js, line 222

setPosition(position)

Set position in source document

Parameters:

Name	Type	Description
`position`	number	Character position

Source:

ragno/SemanticUnit.js, line 132

setPrefLabel(label, langopt)

Set SKOS preferred label

Parameters:

Name	Type	Attributes	Default	Description
`label`	string			Label text
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/models/RDFElement.js, line 125

setProvenance(provenance)

Set provenance information for this attribute

Parameters:

Name	Type	Description
`provenance`	string \| NamedNode	Provenance source URI or node

Source:

ragno/Attribute.js, line 127

setRelationshipType(relType)

Set the relationship type (semantic classification)

Parameters:

Name	Type	Description
`relType`	string	Relationship type (e.g., "causal", "temporal", "part-of")

Source:

ragno/Relationship.js, line 125

setSPARQLEndpoint(sparqlEndpoint)

Set SPARQL endpoint for exact matching

Parameters:

Name	Type	Description
`sparqlEndpoint`	string	SPARQL endpoint URL

Source:

ragno/search/DualSearch.js, line 810

setSPARQLEndpoint(sparqlEndpoint)

Set SPARQL endpoint

Parameters:

Name	Type	Description
`sparqlEndpoint`	string	SPARQL endpoint URL

Source:

ragno/search/SearchAPI.js, line 630

setSPARQLEndpoint(sparqlEndpoint)

Set SPARQL endpoint

Parameters:

Name	Type	Description
`sparqlEndpoint`	string	SPARQL endpoint URL

Source:

ragno/search/index.js, line 567

setSimilarityScore(score)

Set similarity score for this element

Parameters:

Name	Type	Description
`score`	number	Similarity score

Source:

ragno/models/RDFElement.js, line 240

setSourceDocument(source)

Set source document for this unit

Parameters:

Name	Type	Description
`source`	string \| NamedNode	Source document URI or node

Source:

ragno/SemanticUnit.js, line 113

setSourceEntity(sourceEntity)

Set the source entity for this relationship

Parameters:

Name	Type	Description
`sourceEntity`	RDFElement \| NamedNode \| string	Source entity

Source:

ragno/Relationship.js, line 63

setSubType(subType)

Set sub-type for this element

Parameters:

Name	Type	Description
`subType`	string	Sub-type identifier

Source:

ragno/models/RDFElement.js, line 173

setSummary(summary, langopt)

Set summary for this attribute (stored as SKOS definition)

Parameters:

Name	Type	Attributes	Default	Description
`summary`	string			Summary text
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/Attribute.js, line 90

setSummary(summary, langopt)

Set summary for this unit (stored as SKOS definition)

Parameters:

Name	Type	Attributes	Default	Description
`summary`	string			Summary text
`lang`	string	<optional>	'en'	Language tag

Source:

ragno/SemanticUnit.js, line 95

setTargetEntity(targetEntity)

Set the target entity for this relationship

Parameters:

Name	Type	Description
`targetEntity`	RDFElement \| NamedNode \| string	Target entity

Source:

ragno/Relationship.js, line 85

setTemperature(temperature)

Parameters:

Name	Type	Description
`temperature`	number

Source:

handlers/LLMHandler.js, line 313

Throws:

If temperature is invalid
Type Error

setTemporal(timestamp)

Set temporal information for this attribute (when it was true/relevant)

Parameters:

Name	Type	Description
`timestamp`	Date \| string	Temporal information

Source:

ragno/Attribute.js, line 181

setText(text)

Set the main text content for this attribute

Parameters:

Name	Type	Description
`text`	string	Text content

Source:

ragno/Attribute.js, line 73

setText(text)

Set the main text content for this unit

Parameters:

Name	Type	Description
`text`	string	Text content

Source:

ragno/SemanticUnit.js, line 78

setVectorIndex(vectorIndex)

Set vector index for similarity search

Parameters:

Name	Type	Description
`vectorIndex`	VectorIndex	Vector index instance

Source:

ragno/search/DualSearch.js, line 801

setVectorIndex(vectorIndex)

Set vector index

Parameters:

Name	Type	Description
`vectorIndex`	VectorIndex	Vector index instance

Source:

ragno/search/SearchAPI.js, line 620

setWeight(weight)

Set the weight for this relationship

Parameters:

Name	Type	Description
`weight`	number	Relationship weight

Source:

ragno/Relationship.js, line 107

setupDebug()

Debug message display

Source:

frontend/js/utils/_debug.js, line 8

setupErrorHandling()

Setup global error handling

Source:

frontend/js/utils/errorHandler.js, line 42

setupEventListeners()

Setup event listeners for memory controls

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 59

setupFailsafeTimeout()

Setup failsafe timeout for loading indicator

Source:

frontend/js/_app.js, line 170

setupQuickActions()

Setup quick action buttons for common memory operations

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 109

showLoading()

Show/hide loading indicator

Source:

frontend/js/utils/_api.js, line 37

shuffleArray(array) → {Array}

Shuffle array in place

Parameters:

Name	Type	Description
`array`	Array	Array to shuffle

Source:

ragno/algorithms/CommunityDetection.js, line 556

Returns:

Shuffled array

Type: Array

shuffleArray(array) → {Array}

Shuffle array in place using Fisher-Yates algorithm

Parameters:

Name	Type	Description
`array`	Array	Array to shuffle

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 414

Returns:

Shuffled array

Type: Array

(async, abstract) shutdown()

Shutdown the API instance

Source:

api/common/BaseAPI.js, line 31

(async) shutdown()

Shutdown search system and cleanup resources

Source:

ragno/search/index.js, line 627

(async) shutdownAll()

Shutdown all registered APIs

Source:

api/common/APIRegistry.js, line 121

simpleHash()

Simple hash function for parameter caching

Source:

zpt/parameters/ParameterNormalizer.js, line 352

(async) splitLargeSection()

Split large section into sub-chunks

Source:

zpt/transform/ContentChunker.js, line 708

(async) stopAllTraining()

Stop all training processes

Source:

services/vsom/VSOMService.js, line 451

(async) stopTraining()

Stop ongoing training

Source:

api/features/VSOMAPI.js, line 276

stopTraining()

Stop training if currently running

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 425

(async) stopTraining(instanceId) → {Promise.<Object>}

Stop ongoing training for an instance

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier

Source:

services/vsom/VSOMService.js, line 218

Returns:

Stop result

Type: Promise.<Object>

(async) store(data)

Store an entity or memory item with embedding

Parameters:

Name	Type	Description
`data`	Object	Data to store (must have id, embedding, etc.)

Source:

stores/SPARQLStore.js, line 1286

(async) storeCommunity(community) → {Promise.<void>}

Store a ragno:Community with members and aggregation data

Parameters:

Name	Type	Description
`community`	Object	Community data with members and statistics

Source:

stores/SPARQLStore.js, line 828

Returns:

Type: Promise.<void>

(async) storeConceptRelationships(relationships)

Store concept relationships discovered through analysis

Parameters:

Name	Type	Description
`relationships`	Array	Array of relationship objects

Source:

stores/SPARQLStore.js, line 1390

(async) storeConcepts(concepts, sourceEntityUri)

Store extracted concepts as proper RDF entities with relationships

Parameters:

Name	Type	Description
`concepts`	Array	Array of concept objects from extraction
`sourceEntityUri`	string	URI of the entity these concepts were extracted from

Source:

stores/SPARQLStore.js, line 1329

(async) storeDocument(documentData) → {Promise.<void>}

Store large document directly without memory processing Used when content is too large for embedding generation

Parameters:

Name	Type	Description
`documentData`	Object	Document data to store

Source:

stores/SPARQLStore.js, line 1941

Returns:

Type: Promise.<void>

storeEmbeddingInRDF(nodeUri, embeddingData, dataset, rdfManager)

Store embedding information in RDF dataset

Parameters:

Name	Type	Description
`nodeUri`	string	Node URI
`embeddingData`	Object	Embedding data
`dataset`	Dataset	RDF dataset
`rdfManager`	RDFGraphManager	RDF manager

Source:

ragno/enrichWithEmbeddings.js, line 459

(async) storeEntity(entity) → {Promise.<void>}

Store a ragno:Entity with full metadata and relationships

Parameters:

Name	Type	Description
`entity`	Object	Entity data with id, label, type, embedding, etc.

Source:

stores/SPARQLStore.js, line 703

Returns:

Type: Promise.<void>

(async, abstract) storeInteraction(interaction)

Store an interaction

Parameters:

Name	Type	Description
`interaction`	Object	Interaction data

Source:

api/common/BaseAPI.js, line 53

(async) storeInteraction()

Store an interaction in memory

Source:

api/features/MemoryAPI.js, line 75

(async) storeInteraction()

Store interaction (inherited from BaseAPI)

Source:

api/features/RagnoAPI.js, line 814

(async) storeInteraction()

Store interaction (inherited from BaseAPI)

Source:

api/features/UnifiedSearchAPI.js, line 715

(async) storeInteraction()

Store interaction (inherited from BaseAPI)

Source:

api/features/ZptAPI.js, line 601

(async) storeLazyContent(data) → {Promise.<void>}

Store content lazily without processing (no embeddings or concept extraction) Uses ragno vocabulary to store raw content for later processing

Parameters:

Name	Type	Description
`data`	Object	Content data with id, content, type, metadata

Source:

stores/SPARQLStore.js, line 1786

Returns:

Type: Promise.<void>

(async) storeNavigationData()

Store navigation data as ZPT RDF metadata

Source:

zpt/selection/CorpuscleSelector.js, line 563

(async) storeRelationship(relationship) → {Promise.<void>}

Store a ragno:Relationship with source, target and properties

Parameters:

Name	Type	Description
`relationship`	Object	Relationship data with source, target, type

Source:

stores/SPARQLStore.js, line 789

Returns:

Type: Promise.<void>

(async) storeSemanticUnit(unit) → {Promise.<void>}

Store a ragno:SemanticUnit with content and relationships

Parameters:

Name	Type	Description
`unit`	Object	Semantic unit data with content, entities, embedding

Source:

stores/SPARQLStore.js, line 747

Returns:

Type: Promise.<void>

(async) storeSession()

Store a navigation session with RDF metadata

Source:

api/features/ZptAPI.js, line 720

(async) storeZPTDataInSPARQL()

Store ZPT session and view data in SPARQL

Source:

zpt/selection/CorpuscleSelector.js, line 670

(async) streamChatResponse()

Stream a chat response with memory context

Source:

api/features/ChatAPI.js, line 156

summarizeContext()

Create a concise summary of interactions grouped by concept

Source:

ContextManager.js, line 75

summarizeFilters()

Utility methods

Source:

zpt/transform/MetadataEncoder.js, line 641

summarizeFilters()

Helper methods for specific formatting tasks

Source:

zpt/transform/PromptFormatter.js, line 750

supportsTilt(zoomLevel, tiltRepresentation) → {boolean}

Determine if zoom level supports a specific tilt representation

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level
`tiltRepresentation`	string	The tilt representation

Source:

zpt/selection/ZoomLevelMapper.js, line 292

Returns:

Whether the combination is supported

Type: boolean

(async) switchToProject()

Switch to a specific project

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 508

timeOperation()

Simple timing wrapper for functions

Source:

utils/PerformanceTiming.js, line 423

toNTriples() → {string}

Export dataset to N-Triples format

Source:

ragno/core/RDFGraphManager.js, line 252

Returns:

N-Triples serialization

Type: string

toNTriples() → {string}

Export this element as N-Triples

Source:

ragno/models/RDFElement.js, line 351

Returns:

N-Triples representation

Type: string

toSimpleObject() → {Object}

Convert to simple object representation (for backward compatibility)

Source:

ragno/Attribute.js, line 387

Returns:

Simple object representation

Type: Object

toSimpleObject() → {Object}

Convert to simple object representation (for RagnoMemoryStore compatibility)

Source:

ragno/Entity.js, line 367

Returns:

Simple object representation

Type: Object

toSimpleObject() → {Object}

Convert to simple object representation (for backwards compatibility)

Source:

ragno/Relationship.js, line 312

Returns:

Simple object representation

Type: Object

toSimpleObject() → {Object}

Convert to simple object representation (for backward compatibility)

Source:

ragno/SemanticUnit.js, line 416

Returns:

Simple object representation

Type: Object

toTurtle() → {string}

Export this element as Turtle (simplified)

Source:

ragno/models/RDFElement.js, line 366

Returns:

Turtle representation

Type: string

(async) tokenAwareChunking()

Token-aware chunking strategy

Source:

zpt/transform/ContentChunker.js, line 390

toroidalDistance(delta, size) → {number}

Calculate toroidal distance (shortest path around torus)

Parameters:

Name	Type	Description
`delta`	number	Raw coordinate difference
`size`	number	Size of the dimension

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 117

Returns:

Shortest toroidal distance

Type: number

touch()

Update last accessed timestamp to now

Source:

ragno/Entity.js, line 180

trackActiveRequest()

Request tracking

Source:

zpt/api/NavigationEndpoint.js, line 653

(async) train(optionsopt) → {Promise.<Object>}

Train the VSOM on loaded data

Parameters:

Name	Type	Attributes	Description
`options`	Object	<optional>	Training options

Source:

ragno/algorithms/VSOM.js, line 261

Returns:

Training results

Type: Promise.<Object>

(async) train(vsomCore, topology, trainingData, callbacks) → {Object}

Execute complete training process

Parameters:

Name	Type	Description
`vsomCore`	Object	VSOM core algorithm instance
`topology`	Object	VSOM topology instance
`trainingData`	Array	Array of training vectors
`callbacks`	Object	Optional training callbacks

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 81

Returns:

Training results

Type: Object

(async) train(instanceId, options) → {Promise.<Object>}

Train a VSOM instance

Parameters:

Name	Type	Description
`instanceId`	string	Instance identifier
`options`	Object	Training options

Source:

services/vsom/VSOMService.js, line 126

Returns:

Training result

Type: Promise.<Object>

(async) trainSOM()

Train a SOM instance

Source:

api/features/VSOMAPI.js, line 239

(async) trainingStep(vsomCore, topology, trainingData, learningRate, neighborhoodRadius, neighborhoodFunction) → {Object}

Perform single training step

Parameters:

Name	Type	Description
`vsomCore`	Object	VSOM core algorithm instance
`topology`	Object	VSOM topology instance
`trainingData`	Array	Training data
`learningRate`	number	Current learning rate
`neighborhoodRadius`	number	Current neighborhood radius
`neighborhoodFunction`	function	Neighborhood function

Source:

ragno/algorithms/vsom/VSOMTraining.js, line 188

Returns:

Iteration results

Type: Object

(async) transform(projectedContent, selectionResult, transformOptions) → {Promise.<Object>}

Main transformation method - orchestrates the complete pipeline

Parameters:

Name	Type	Description
`projectedContent`	Object	Content from TiltProjector
`selectionResult`	Object	Result from CorpuscleSelector
`transformOptions`	Object	Transformation parameters

Source:

zpt/transform/CorpuscleTransformer.js, line 115

Returns:

Complete transformation result

Type: Promise.<Object>

transformDocQAToVSOM()

Transform document-QA SPARQL results to VSOM entity format

Source:

api/features/VSOMAPI.js, line 603

transformToCorpuscles()

Transform SPARQL results to corpuscle format

Source:

zpt/selection/CorpuscleSelector.js, line 222

transformToDocument(binding) → {Object}

Transform SPARQL result binding to document object

Parameters:

Name	Type	Description
`binding`	Object	SPARQL result binding

Source:

services/ingestion/SPARQLDocumentIngester.js, line 167

Returns:

Document object ready for MCP tell method

Type: Object

(async) transformToUnits(searchObject) → {Promise.<Array>}

Transform Wikipedia search results to RDF units

Parameters:

Name	Type	Description
`searchObject`	Object	Search results object

Source:

aux/wikipedia/Search.js, line 187

Returns:

Array of RDF unit data

Type: Promise.<Array>

(async) traverseGraph(startNodeId, depth, options) → {Promise.<Object>}

Graph traversal query with configurable depth

Parameters:

Name	Type	Default	Description
`startNodeId`	string		Starting node URI
`depth`	number	2	Maximum traversal depth
`options`	Object		Traversal options (direction, relationTypes)

Source:

stores/SPARQLStore.js, line 1089

Returns:

Graph structure with nodes and edges

Type: Promise.<Object>

(async) unifiedSearch()

Main unified search that queries all available services and merges results

Source:

api/features/UnifiedSearchAPI.js, line 147

(async) unregister()

Remove and cleanup an API instance

Source:

api/common/APIRegistry.js, line 56

updateConfig()

Update configuration

Source:

aux/ResearchService.js, line 354

updateConfig()

Configuration methods

Source:

zpt/api/ErrorHandler.js, line 703

updateConfig()

Update parser configuration

Source:

zpt/api/RequestParser.js, line 630

updateConfig()

Configuration methods

Source:

zpt/api/ResponseFormatter.js, line 922

updateDomainDisplay()

Update domain display

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 653

updateGraph()

Override updateGraph to queue Ragno sync operations

Source:

stores/RagnoMemoryStore.js, line 25

(async) updateLazyToProcessed(elementId, embedding, concepts) → {Promise.<void>}

Update lazy content to processed status

Parameters:

Name	Type	Description
`elementId`	string	Element ID to update
`embedding`	Array	Generated embedding
`concepts`	Array	Extracted concepts

Source:

stores/SPARQLStore.js, line 1895

Returns:

Type: Promise.<void>

updateMemoryDisplay()

Update memory display

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 627

updateMemoryStats()

Update memory statistics

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 636

updateMetrics()

Metrics tracking

Source:

zpt/api/NavigationEndpoint.js, line 685

updateMetrics()

Update performance metrics

Source:

zpt/selection/CorpuscleSelector.js, line 915

updateMetrics()

Metrics and monitoring

Source:

zpt/transform/CorpuscleTransformer.js, line 832

updateModified()

Update the modified timestamp

Source:

ragno/models/RDFElement.js, line 302

updateProjectDisplay()

Update project display

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 663

updateRequestStats(responseTime, type)

Update request statistics

Parameters:

Name	Type	Default	Description
`responseTime`	number		Response time in ms
`type`	string	general	Request type

Source:

ragno/search/SearchAPI.js, line 585

updateSearchStatistics(searchTime, exactResults, vectorResults, pprResults)

Update search statistics

Parameters:

Name	Type	Description
`searchTime`	number	Time taken for search
`exactResults`	Array	Exact match results
`vectorResults`	Array	Vector similarity results
`pprResults`	Object	PPR traversal results

Source:

ragno/search/DualSearch.js, line 777

updateUI()

Update UI components

Source:

frontend/workbench/public/js/components/MemoryComponent.js, line 673

updateWeights(inputBatch, bmuIndices, learningRate, neighborhoodRadius, neighborhoodFunction)

Update weights for a batch of training samples

Parameters:

Name	Type	Description
`inputBatch`	Array	Batch of input vectors
`bmuIndices`	Array	BMU indices for each input
`learningRate`	number	Current learning rate
`neighborhoodRadius`	number	Current neighborhood radius
`neighborhoodFunction`	function	Neighborhood weight function

Source:

ragno/algorithms/vsom/VSOMCore.js, line 244

(async) uploadDocument()

Upload and process a document file

Source:

api/features/DocumentAPI.js, line 130

validate() → {Object}

Validate this attribute according to ragno ontology

Source:

ragno/Attribute.js, line 329

Returns:

Validation result

Type: Object

validate() → {Object}

Validate this entity according to ragno ontology

Source:

ragno/Entity.js, line 317

Returns:

Validation result

Type: Object

validate() → {Object}

Validate this relationship according to ragno ontology

Source:

ragno/Relationship.js, line 260

Returns:

Validation result

Type: Object

validate() → {Object}

Validate this unit according to ragno ontology

Source:

ragno/SemanticUnit.js, line 364

Returns:

Validation result

Type: Object

validate() → {Object}

Validate this element against ragno ontology constraints

Source:

ragno/models/RDFElement.js, line 324

Returns:

Validation result with errors array

Type: Object

validate(html) → {Object}

Validate HTML content

Parameters:

Name	Type	Description
`html`	string	HTML content to validate

Source:

services/document/HTMLConverter.js, line 183

Returns:

Validation result

Type: Object

(async) validate(filePath) → {Promise.<Object>}

Validate PDF file

Parameters:

Name	Type	Description
`filePath`	string	Path to PDF file

Source:

services/document/PDFConverter.js, line 138

Returns:

Validation result

Type: Promise.<Object>

validate(params) → {Object}

Validate complete ZPT parameter object

Parameters:

Name	Type	Description
`params`	Object	Navigation parameters

Source:

zpt/parameters/ParameterValidator.js, line 100

Returns:

Validation result

Type: Object

validateCompatibility(zoomLevel, panFilters, tiltRepresentation) → {Object}

Validate zoom level compatibility with parameters

Parameters:

Name	Type	Description
`zoomLevel`	string	The zoom level
`panFilters`	Object	Pan filter parameters
`tiltRepresentation`	string	Tilt representation

Source:

zpt/selection/ZoomLevelMapper.js, line 387

Returns:

Validation result

Type: Object

validateConfig(config) → {Object}

Validate chunking configuration

Parameters:

Name	Type	Description
`config`	Object	Configuration to validate

Source:

services/document/Chunker.js, line 342

Returns:

Validation result

Type: Object

validateConfig()

Validate parser configuration

Source:

zpt/api/RequestParser.js, line 637

validateConfiguration() → {Object}

Validate topology configuration

Source:

ragno/algorithms/vsom/VSOMTopology.js, line 391

Returns:

Validation result {valid: boolean, errors: Array}

Type: Object

validateContentType()

Request validators

Source:

zpt/api/RequestParser.js, line 466

(async) validateCorpus() → {Promise.<Object>}

Get corpus health and statistics

Source:

stores/SPARQLStore.js, line 1196

Returns:

Health check results with statistics

Type: Promise.<Object>

validateCriteria()

Validate selection criteria

Source:

zpt/parameters/SelectionCriteria.js, line 512

(async) validateDependencies()

Validate dependencies before initialization

Source:

zpt/api/NavigationEndpoint.js, line 776

validateGeographic()

Validate geographic filter

Source:

zpt/parameters/ParameterValidator.js, line 309

(async) validateInput()

Pipeline stage implementations

Source:

zpt/transform/CorpuscleTransformer.js, line 270

validateJsonStructure(data, expectedType, options) → {boolean}

Validate that parsed JSON matches expected structure

Parameters:

Name	Type	Default	Description
`data`	any		Parsed JSON data
`expectedType`	string	array	'array' or 'object'
`options`	Object		Validation options

Source:

utils/ParseHelper.js, line 212

Returns:

True if valid

Type: boolean

validateMetadata()

Validation methods

Source:

zpt/transform/MetadataEncoder.js, line 831

(async) validateMigration()

Validate migration results

Source:

migration/DataMigration.js, line 355

validateMigration()

Validate migration results

Source:

prompts/migrate-existing.js, line 249

validateModel(model) → {boolean}

Parameters:

Name	Type	Description
`model`	string

Source:

handlers/LLMHandler.js, line 324

Returns:

Type: boolean

validateNormalized()

Validate that normalized parameters are complete

Source:

zpt/parameters/ParameterNormalizer.js, line 365

(async) validateOntology()

Validate parameters against ZPT ontology

Source:

api/features/ZptAPI.js, line 1053

validateOptions()

Validate formatting options

Source:

zpt/transform/PromptFormatter.js, line 927

validatePan()

Validate pan parameter

Source:

zpt/parameters/ParameterValidator.js, line 208

validateQuery()

Validate that query can be executed

Source:

zpt/parameters/FilterBuilder.js, line 652

validateRagnoURI(uri, expectedType) → {boolean}

Validate that a URI follows ragno ontology patterns

Parameters:

Name	Type	Description
`uri`	string	URI to validate
`expectedType`	string	Expected type (class, property, individual)

Source:

ragno/core/NamespaceManager.js, line 328

Returns:

True if valid

Type: boolean

(async) validateRequest()

Validate complete request structure

Source:

zpt/api/RequestParser.js, line 96

validateSearchRequest(req) → {Object}

Validate search request

Parameters:

Name	Type	Description
`req`	Object	Express request object

Source:

ragno/search/SearchAPI.js, line 443

Returns:

Validation result

Type: Object

validateTemporal()

Validate temporal filter

Source:

zpt/parameters/ParameterValidator.js, line 262

validateTilt()

Validate tilt parameter

Source:

zpt/parameters/ParameterValidator.js, line 185

validateTransform()

Validate transform parameter

Source:

zpt/parameters/ParameterValidator.js, line 364

validateZoom()

Validate zoom parameter

Source:

zpt/parameters/ParameterValidator.js, line 162

(async) verifyComponentsReady()

Verify all components are ready after initialization

Source:

zpt/api/NavigationEndpoint.js, line 850

(async) withRateLimit()

Execute a function with rate limiting and exponential backoff

Source:

handlers/LLMHandler.js, line 114

withTiming()

Timing decorator for functions

Source:

utils/PerformanceTiming.js, line 396

Type Definitions

ChatMessage

Language model provider interface

Type:

Object

Source:

handlers/LLMHandler.js, line 5