Struct DynamicGraphModel 

pub struct DynamicGraphModel {
    pub name: String,
    pub schema: Value,
    pub description: Option<String>,
    pub source: Option<String>,
}

A runtime representation of a graph model’s JSON schema.

Stores the JSON schema for a graph model so it can be serialized, transmitted between SDKs, and used for LLM structured output without requiring the concrete Rust type at runtime.

Fields

• name - Human-readable name for the model (e.g., “KnowledgeGraph”, “ProgrammingLanguage”)
• schema - The JSON schema as a serde_json::Value
• description - Optional description of what the model represents
• source - Optional source identifier (e.g., “python-sdk”, “rust-sdk”)

Fields

name: String

Human-readable name for the model.

schema: Value

The JSON schema describing the model’s structure.

description: Option<String>

Optional description of what the model represents.

source: Option<String>

Optional source identifier (e.g., “python-sdk”, “rust-sdk”).

Implementations

impl DynamicGraphModel

pub fn from_type<T>(name: impl Into<String>) -> DynamicGraphModel

where T: JsonSchema,

Create a DynamicGraphModel from a Rust type that implements JsonSchema.

Generates the JSON schema at runtime via schemars and stores it alongside the given name. The source field is automatically set to "rust-sdk".

Arguments

• name - Human-readable name for the model

Example

use cognee_llm::DynamicGraphModel;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, JsonSchema, Clone)]
struct PersonGraph {
    people: Vec<String>,
    relationships: Vec<(String, String)>,
}

let model = DynamicGraphModel::from_type::<PersonGraph>("PersonGraph");
assert_eq!(model.name, "PersonGraph");
assert_eq!(model.source.as_deref(), Some("rust-sdk"));

pub fn from_schema(name: impl Into<String>, schema: Value) -> DynamicGraphModel

Create a DynamicGraphModel from a pre-existing JSON schema.

Use this when receiving a schema from an external source (e.g., the Python SDK serialized a Pydantic model to JSON schema).

Arguments

• name - Human-readable name for the model
• schema - The JSON schema as a serde_json::Value

Example

use cognee_llm::DynamicGraphModel;

let schema = serde_json::json!({
    "type": "object",
    "properties": {
        "name": { "type": "string" }
    },
    "required": ["name"]
});
let model = DynamicGraphModel::from_schema("ExternalModel", schema);
assert_eq!(model.name, "ExternalModel");
assert!(model.source.is_none());

pub fn with_description( self, description: impl Into<String>, ) -> DynamicGraphModel

Set an optional description on this model.

pub fn with_source(self, source: impl Into<String>) -> DynamicGraphModel

Set an optional source identifier on this model.

pub fn has_properties(&self) -> bool

Check whether the schema has a "properties" key (i.e., looks like an object schema).

This is a lightweight structural check, not full JSON Schema validation. For full structural validation, deserialize with serde_json::from_value::<T>() which enforces all type constraints.

pub fn required_fields(&self) -> Option<Vec<&str>>

Get the list of required field names from the schema, if any.

Returns None if the schema has no "required" key. Returns Some(vec) with the field names otherwise.

pub fn check_required_fields(&self, instance: &Value) -> Result<(), String>

Check whether a JSON value has all the required fields defined in this schema.

This performs a lightweight check: it only verifies that required fields exist as keys in the JSON object. It does not validate types or nested structures. For full structural validation, use serde_json::from_value::<T>().

Returns Ok(()) if all required fields are present (or if there are no required fields). Returns Err with a message listing missing fields.

Trait Implementations

impl Clone for DynamicGraphModel

fn clone(&self) -> DynamicGraphModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DynamicGraphModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DynamicGraphModel

fn deserialize<__D>( __deserializer: __D, ) -> Result<DynamicGraphModel, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DynamicGraphModel

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.