Overview
The GL AIP (GDP Labs AI Agents Package) delivers a managed REST platform for building and running AI agents. This repository layers on a Python SDK and CLI so you can use identical features locally, in CI, or inside your own applications.
Documentation map
Use these sections in order when exploring the SDK and CLI:
Get Started — Install, configure, complete the quick start, and run curated examples.
Guides — Deep dives on lifecycle management, automation, integrations, and governance.
Multi-Agent System Patterns — Runnable orchestration templates for complex workflows.
Reference — Definitive API, SDK, and CLI commands for implementation details.
Resources — Changelog, glossary, and upgrade checklists.
Role-Based entry points
Choose the track that matches how you work today.
Engineers — Ship agents in applications and automation
Why it matters: You need reliable APIs, typed clients, and testable workflows that fit existing services.
Start here:
Quick Start Guide for first-run success.
Python SDK Reference for signatures and streaming behaviour.
Automation & Scripting for CI, cron, and deployment patterns.
Product Managers — Validate agents via GLChat
Why it matters: You review agent behaviour for stakeholders. GLChat gives you fast access, but the CLI helps you list available agents and capture verbose output when needed.
Start here:
Quick Start Guide (CLI path) — run an agent end-to-end and see detailed logs.
Agents guide › List & run — discover agent IDs/names before launching them in GLChat.
Automation & Scripting › Choose the right output — switch between rich and plain responses when sharing findings.
Data Developers — Curate prompts, evaluations, and linguistic QA
Why it matters: You iterate on prompts, run guided evaluations, and need to inspect agent transcripts without writing code.
Start here:
Quick Start Guide — follow the CLI path to validate access and run agents.
Configuration management guide — master CLI export/import loops for prompt iteration.
CLI Commands Reference — look up flags for runs, exports, and transcript capture.
Choose your interface
Pick the surface that matches your environment; each summary spells out when and why to use it.
REST API — Language-agnostic integration with full control
Why you would pick it
Works with any language or infrastructure stack.
Provides immediate access to every capability, including roadmap features as soon as they land.
Use it when
Orchestrating agents from existing services, queues, or infrastructure.
You need custom authentication flows or to run in tightly restricted environments.
Key docs
Python SDK — Type-safe development and faster iteration
Why you would pick it
Typed client with ergonomic streaming and error handling.
Shared utilities mirroring the CLI and test fixtures so you can reuse code between notebooks, services, and pipelines.
Use it when
Building Python services, workflows, or notebooks that call AIP frequently.
You want to prototype locally, then promote the same code path into CI/CD.
Key docs
CLI — Fast experiments, ops checks, and demos
Why you would pick it
Zero-code access with rich terminal rendering and JSON exports.
Ideal for smoke-testing environments, running scheduled jobs, or supporting teams without direct code access.
Use it when
Validating connectivity or resources before automation.
Running guided demos, QA checklists, or manual evaluations.
Data developers iterate on prompts with export/import loops and need transcripts fast.
Key docs
Platform capabilities at a glance
Symbols: ✅ fully supported · 🛠️ partial via customization/workarounds · 🚧 roadmap
Roadmap (🚧) items are available via the REST API first. The SDK and CLI pick them up as soon as the corresponding clients and commands ship.
Core Operations
Agent lifecycle & metadata
Create/list/update/delete agents with tools, MCPs, and sub-agents
✅
✅
✅
Streaming execution & artifacts
SSE runs, file uploads, usage stats, artifact links
✅
✅
✅
Multi-agent orchestration
Nested agents, LangFlow imports, delegated execution patterns
✅
✅
✅
File ingestion & chunking
Multipart uploads, chunk ID management, artifact reuse
✅
✅
✅
Tool registry & uploads
Native catalog, custom uploads, BOSA connectors
✅
✅
✅
Memory & conversation persistence
agent_config.memory, chat history injection, mem0 retention
✅
✅
🛠️
Tool output sharing controls
Toggle agent_config.tool_output_sharing to share artifacts
✅
✅
🛠️
Automation & Integrations
Configuration export/import
JSON/YAML round-tripping for agents and tools
✅
✅
✅
Language model routing
language_model_id, provider/model fallbacks, per-run overrides
✅
✅
🛠️
MCP connectors & auth rotation
MCP CRUD, /mcps/connect, tool discovery
✅
✅
✅
MCP runtime overrides
Per-run runtime_config.mcp_configs overrides
✅
✅
🚧
LangFlow workflow sync
/agents/langflow/sync promotion of flows into agents
✅
✅
✅
Human-in-the-loop approvals
/agents/hitl/* endpoints for manual decision checkpoints
✅
🛠️
🛠️
Run history & analytics
/agents/{id}/runs pagination, status filters, usage metrics
✅
🚧
🚧
Schedules & triggers
/schedules CRUD for cron/interval/webhook automation
✅
🚧
🚧
Governance & Roadmap
PII tagging & redaction
pii_mapping masking for inbound/outbound payloads
✅
✅
🚧
Account lifecycle
/accounts create/list/delete with master key guardrails
✅
🚧
🚧
Multi-account isolation
API-key scoped requests, master key bypass
✅
✅
✅
RBAC role management
Creator/Runner/Viewer roles, delegated keys
🚧
🚧
🚧
How it fits together
The SDK and CLI sit on top of the same REST endpoints exposed by AIP. Tokens and base URLs are shared across interfaces, so you can develop locally and promote the same configuration into CI or production with minimal changes.
REST API is the ground truth: every capability is implemented here first.
Python SDK wraps the API with typed models, streaming helpers, and higher-level abstractions.
CLI uses the SDK under the hood so operations and demos mirror production behaviour.
Start building
Install & configure
Set up credentials and the CLI with Install & Configure.
Run the quick start
Choose the CLI or SDK path in the Quick Start Guide to create and run your first agent.
Iterate on prompts
Use the CLI export/import loop in Configuration management to refine instructions safely.
Add real workflows
Explore Tools, File processing, or Multi-agent patterns as you expand capabilities.
The GL AIP package, SDK, and CLI give you a single, consistent toolkit to build, test, and operate AI agents anywhere.
Last updated