> ## Documentation Index > Fetch the complete documentation index at: https://koreai.mintlify.app/llms.txt > Use this file to discover all available pages before exploring further. # Get Started with AgenticAI Core SDK This concise introduction to the AgenticAI Core SDK consolidates concepts, setup, and a minimal end-to-end workflow into a single logical flow for software developers and system integrator partners. | Section | Purpose | | -------------------------------------------------------------------------- | ------------------------------------------ | | [1. What Is AgenticAI Core](#1-what-is-agenticai-core) | What the SDK does and when to use it | | [2. Architecture and Core Concepts](#2-architecture-and-core-concepts) | Mental model and key building blocks | | [3. Installation and Setup](#3-installation-and-setup) | Local workspace and Platform configuration | | [4. First Application Flow](#4-first-application-flow) | Minimal end-to-end example | | [5. Development Lifecycle](#5-development-lifecycle) | Build → test → package → deploy | | [6. Beginner Best Practices](#6-best-practices) | Practical guidance | | [7. Advanced Concepts and Next Steps](#7-advanced-concepts-and-next-steps) | Where to go after this guide | *** ## 1. What Is AgenticAI Core AgenticAI Core is a Python SDK for building and deploying multi-agent AI applications. You define agents, tools, models, and orchestration in Python (**design-time**) and execute them through a runtime that exposes an MCP server. Typical uses include customer-facing assistants, workflow automation, and domain-specific AI systems that require multiple specialized agents. *** ## 2. Architecture and Core Concepts ### Design-Time and Runtime Design-time focuses on describing *what exists* in your application, while runtime focuses on *how requests are executed*. ``` Design-Time -> App + Agents + Tools + Models Runtime -> MCP Server -> Orchestrator -> Agents -> Tools ``` ### Main Building Blocks An **App** is the top-level container that groups agents and defines orchestration. **Agents** perform domain-specific work and may reason (REACT) or proxy to external systems. **Tools** are callable actions, typically Python functions registered with `@Tool.register`. **LLM models** define how agents reason, while **prompts** constrain behavior. **Memory stores** persist context, and **orchestration** controls routing between agents. Together, a request flows as: ``` Client -> MCP Server -> Orchestrator -> Agent -> (LLM <-> Tools) -> Response ``` For details, see the [SDK architecture](/agent-platform/sdk/architecture). *** ## 3. Installation and Setup ### Prerequisites You need Python 3.10+, pip, and Git. The SDK is provided through a private workspace repository. [Contact support](https://support.kore.ai/). ### Workspace Setup Clone the workspace and run the setup script: ```bash theme={null} git clone cd workspace chmod +x .setup.sh ./.setup.sh ``` The script creates a `.venv` virtual environment, installs `agenticai-core` and its dependencies. Always keep the virtual environment named `.venv`. {/* If you prefer a manual workspace setup, see [this article](/agent-platform/sdk/manual-configuration). */ } ### Platform Configuration Before building applications, configure access to the AgenticAI platform. Create an application and API key in the AgenticAI platform, then define environment variables. Create separate configs for different environments such as `.env/dev`, `.env/staging`, or `.env/prod`. ```bash theme={null} # .env/dev KORE_HOST=https://agent-platform.kore.ai APP_API_KEY=your_api_key TRACING_ENABLED=True ``` After successful configuration, your workspace looks like: ``` workspace/ ├── .venv/ # Virtual environment (created by setup) ├── .env/ # Environment configurations (you create) │ ├── dev │ ├── staging │ └── prod ├── lib/ # Pre-installed libraries │ ├── agenticai_core-0.1.0-py3-none-any.whl │ └── kore_api-1.0.0-py3-none-any.whl ├── src/ │ ├── tools/ # Your custom tools │ ├── orchestrator/ # Your custom orchestrators │ └── app.py # Your application definition ├── bin/ # Generated archives (created on archive) ├── examples/ # Example applications ├── .scripts/ # Utility scripts ├── requirements.txt # Dependency list ├── run.py # CLI entry point ├── .setup.sh # Setup script └── README.md # Workspace documentation ``` *** ## 4. First Application Flow This section shows the smallest useful end-to-end path. ### Step 1: Define a Tool ```python theme={null} from agenticai_core.designtime.models.tool import Tool @Tool.register(name="Get_Balance", description="Get account balance") async def get_balance(account_id: str): return {"balance": 1000} ``` ### Step 2: Define an Agent and App ```python theme={null} from agenticai_core.designtime.models import App, Agent app = App( name="Sample App", agents=[Agent(name="DemoAgent")] ) ``` ### Step 3: Run Locally ```bash theme={null} source .venv/bin/activate python run.py start -H localhost -P 8080 ``` ### Step 4: Package and Deploy ```bash theme={null} python run.py package -o sample-app python run.py config -u dev python run.py deploy -f bin/sample-app/application.kar ``` *** ## 5. Development Lifecycle The typical lifecycle is linear and repeatable: ``` Clone -> Setup -> Develop tools -> Test Local -> Package -> Deploy -> Test E2E -> Monitor ``` Local testing happens before packaging, and deployment artifacts are always generated from the workspace. *** ## 6. Best Practices Keep agents narrowly focused, design tools to do one thing well, and test locally before every deployment. Use `.venv` consistently to avoid oversized packages, and save deployment identifiers returned by the Platform for later testing. *** ## 7. Advanced Concepts and Next Steps | Topic | Summary | | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [SDK Architecture](/agent-platform/sdk/architecture) | Covers the SDK's two phases — design-time configuration and runtime execution — and its two components: the `agentic-core` library (design-time builder models, runtime abstract classes, and the MCP server) and the workspace (project scaffold with the `run.py` CLI). Also details memory store configuration with scope and retention options, structured tool logging, and the full deployment sequence from packaging a KAR archive to container provisioning. | | [CLI Reference](/agent-platform/sdk/cli-reference) | Documents all eight `run.py` commands — `config`, `package`, `start`, `deploy`, `publish`, `status`, `undeploy`, and `test` — with full syntax, options, and examples for each. Includes environment configuration for dev, staging, and production environments, a complete lifecycle workflow from local development to production deployment, and troubleshooting guidance for common issues. | | [API Reference](/agent-platform/sdk/api-reference) | Reference for design-time builder classes (`App`, `Agent`, `Tool`, `LlmModel`, `MemoryStore`, `EnvVariable`, `Prompt`, `Icon`) and runtime service APIs (`RequestContext`, `Logger`, `Tracer`), with constructor parameters and method signatures. Covers accessing session context and environment variables, performing memory CRUD operations with field projections, emitting structured logs at four severity levels, and integrating distributed tracing into tools and orchestrators. | | [Examples](/agent-platform/sdk/examples) | Walks through two complete applications: a single-agent banking assistant with custom MCP tools for balance checks and fund transfers, a session-scoped memory store, and a keyword-routing orchestrator; and a multi-agent customer service app with three specialized agents (support, billing, technical) that routes requests by intent and escalates between agents. Both examples include full implementation code, project structure, and CLI commands to package, deploy, and test end to end. | | [Build Applications](/agent-platform/sdk/guide/building-apps) | Covers end-to-end app assembly: defining `App`, configuring agents (LLM + prompts), registering tools, setting up memory stores, configuring advanced features, implementing a custom orchestrator, and starting the MCP server. Includes a complete example and best practices. | | [Create Agents](/agent-platform/sdk/guide/creating-agents) | Explains agent configuration in depth: autonomous vs proxy types, REACT pattern, roles (WORKER/SUPERVISOR), prompt design, LLM settings, tool attachment (builder and direct), metadata, icons, real-time flags, and conversion to `AgentMeta` for orchestration. | | [Work with Tools](/agent-platform/sdk/guide/working-with-tools) | Details tool creation and usage: MCP tools via `@Tool.register`, inline tools, tool library, and knowledge tools. Covers request context access, memory operations inside tools, structured logging, tracing, agent integration, and best practices for error handling and performance. | | [Memory Stores](/agent-platform/sdk/guide/memory-stores) | Describes design-time memory configuration (schema, namespaces, scope, retention), adding stores to apps, and runtime CRUD operations (`set_content`, `get_content`, `delete_content`). Explains scope types, retention policies, projections, schema validation, security, and performance guidance. | | [Prompts and LLM Config](/agent-platform/sdk/guide/prompts-llm) | Covers LLM model setup across providers (OpenAI, Anthropic, Azure), parameter tuning (temperature, tokens, `top_p`, penalties), builder patterns, structured prompt design, template variables, supervisor prompts, security rules, and optimization strategies for cost and quality. | | [Custom Orchestration](/agent-platform/sdk/guide/orchestration) | Explains implementing `AbstractOrchestrator`, message handling protocol (user/tool roles), `ToolCall` and `route_to_user`, routing strategies (keyword, round-robin, task-based), stateful orchestration with memory, tracing integration, and common multi-agent flow patterns. | **Related information:** * [Changelog](/agent-platform/sdk/changelog). * [Contribution Guidelines](/agent-platform/sdk/contributing).