Struct ProjectSchema 

pub struct ProjectSchema {
    pub id: Uuid,
    pub version: String,
    pub name: String,
    pub description: String,
    pub settings: ProjectSettings,
    pub agents: HashMap<String, AgentSchema>,
    pub tools: HashMap<String, ToolSchema>,
    pub tool_configs: HashMap<String, ToolConfig>,
    pub workflow: WorkflowSchema,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Complete project schema

Fields

id: Uuid

version: String

name: String

description: String

settings: ProjectSettings

agents: HashMap<String, AgentSchema>

tools: HashMap<String, ToolSchema>

tool_configs: HashMap<String, ToolConfig>

workflow: WorkflowSchema

created_at: DateTime<Utc>

updated_at: DateTime<Utc>

Implementations

impl ProjectSchema

pub fn new(name: impl Into<String>) -> Self

Examples found in repository

examples/codegen_demo.rs (line 67)

fn simple_chat_project() -> ProjectSchema {
    let mut p = ProjectSchema::new("simple_chat");
    p.agents.insert(
        "chat_agent".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction:
                "You are a helpful, friendly assistant. Answer questions clearly and concisely."
                    .to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "START".to_string(),
        to: "chat_agent".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "chat_agent".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p
}

fn research_pipeline_project() -> ProjectSchema {
    let mut p = ProjectSchema::new("research_pipeline");

    // Sub-agents
    p.agents.insert(
        "researcher".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction:
                "Research the topic using Google Search. Gather key facts and recent developments."
                    .to_string(),
            tools: vec!["google_search".to_string()],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.agents.insert(
        "summarizer".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "Summarize the research into key takeaways and conclusions.".to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    // Sequential container
    p.agents.insert(
        "pipeline".to_string(),
        AgentSchema {
            agent_type: AgentType::Sequential,
            model: None,
            instruction: String::new(),
            tools: vec![],
            sub_agents: vec!["researcher".to_string(), "summarizer".to_string()],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "START".to_string(),
        to: "pipeline".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "pipeline".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p
}

fn content_refiner_project() -> ProjectSchema {
    let mut p = ProjectSchema::new("content_refiner");

    p.agents.insert(
        "improver".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "Improve the content: fix errors, enhance clarity, improve flow."
                .to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.agents.insert(
        "reviewer".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction:
                "Review content quality. Call exit_loop when polished, otherwise continue."
                    .to_string(),
            tools: vec!["exit_loop".to_string()],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    // Loop container
    p.agents.insert(
        "refiner".to_string(),
        AgentSchema {
            agent_type: AgentType::Loop,
            model: None,
            instruction: String::new(),
            tools: vec![],
            sub_agents: vec!["improver".to_string(), "reviewer".to_string()],
            position: Default::default(),
            max_iterations: Some(3),
            routes: vec![],
        },
    );

    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "START".to_string(),
        to: "refiner".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "refiner".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p
}

fn parallel_analyzer_project() -> ProjectSchema {
    let mut p = ProjectSchema::new("parallel_analyzer");

    p.agents.insert(
        "sentiment".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "Analyze sentiment: positive/negative/neutral with key emotional tones."
                .to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.agents.insert(
        "entities".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "Extract entities: people, organizations, locations, dates.".to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    // Parallel container
    p.agents.insert(
        "analyzer".to_string(),
        AgentSchema {
            agent_type: AgentType::Parallel,
            model: None,
            instruction: String::new(),
            tools: vec![],
            sub_agents: vec!["sentiment".to_string(), "entities".to_string()],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "START".to_string(),
        to: "analyzer".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "analyzer".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p
}

fn support_router_project() -> ProjectSchema {
    let mut p = ProjectSchema::new("support_router");

    // Router
    p.agents.insert(
        "router".to_string(),
        AgentSchema {
            agent_type: AgentType::Router,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "Classify request as: technical, billing, or general.".to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![
                Route { condition: "technical".to_string(), target: "tech_agent".to_string() },
                Route { condition: "billing".to_string(), target: "billing_agent".to_string() },
                Route { condition: "general".to_string(), target: "general_agent".to_string() },
            ],
        },
    );

    // Target agents
    p.agents.insert(
        "tech_agent".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "You are technical support. Help with coding and bugs.".to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.agents.insert(
        "billing_agent".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "You are billing support. Help with payments and subscriptions."
                .to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );
    p.agents.insert(
        "general_agent".to_string(),
        AgentSchema {
            agent_type: AgentType::Llm,
            model: Some("gemini-2.0-flash".to_string()),
            instruction: "You are general support. Help with general questions.".to_string(),
            tools: vec![],
            sub_agents: vec![],
            position: Default::default(),
            max_iterations: None,
            routes: vec![],
        },
    );

    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "START".to_string(),
        to: "router".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "router".to_string(),
        to: "tech_agent".to_string(),
        condition: Some("technical".to_string()),
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "router".to_string(),
        to: "billing_agent".to_string(),
        condition: Some("billing".to_string()),
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "router".to_string(),
        to: "general_agent".to_string(),
        condition: Some("general".to_string()),
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "tech_agent".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "billing_agent".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p.workflow.edges.push(adk_studio::schema::Edge {
        from: "general_agent".to_string(),
        to: "END".to_string(),
        condition: None,
    });
    p
}

Trait Implementations

impl Clone for ProjectSchema

fn clone(&self) -> ProjectSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectSchema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProjectSchema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&ProjectSchema> for ProjectMeta

fn from(p: &ProjectSchema) -> Self

Converts to this type from the input type.

impl Serialize for ProjectSchema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.