.png)
Ada Integration Guide
Integrate Ada’s AI customer service platform with enterprise systems through authenticated REST APIs, selected callback patterns, and Martini workflows.
Ada integration options at a glance
Ada provides authenticated REST APIs for interacting with its conversational platform, including customer context, conversations, messages, and platform operations. Ada also supports selected event-style callbacks and external API calls through actions, although webhook coverage must be confirmed for the required tenant and event. Martini can consume Ada REST endpoints, expose controlled APIs for Ada actions or other systems, and orchestrate workflows that map Ada payloads into CRM, commerce, service, or analytics platforms. API keys or bearer credentials may apply depending on the endpoint; OAuth 2.0 should be verified rather than assumed. Large-scale processing should use documented pagination and scheduled incremental workflows rather than an assumed bulk API.
| Integration point | Supported by Ada? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Interact with Ada’s conversational platform, pass customer context, send messages, retrieve conversation information, and invoke platform operations. | Martini can consume Ada REST endpoints from workflows, transform payloads, apply business rules, and expose a separate API façade when required. |
| Webhooks and outbound callbacks | Limited | Exchange event-style data for selected integrations, actions, or lifecycle scenarios. Coverage must be confirmed for the required tenant and event. | Martini can receive an Ada webhook or callback through an exposed API or webhook workflow, authenticate it, transform the payload, and route it downstream. |
| Actions and external API calls | Yes | Allow Ada conversations to check order status, retrieve account information, update service requests, or initiate external business operations. | Martini can expose narrow-purpose REST APIs for Ada actions and orchestrate authentication, validation, target-system calls, response mapping, and controlled fallbacks. |
| Authentication | Yes | Authenticate Ada API requests using the credential model applicable to the endpoint, such as an API key or bearer credential. OAuth 2.0 must be confirmed for the selected surface. | Martini stores credentials in environment configuration or secrets management and applies endpoint-specific authentication without embedding secrets in workflows. |
| Scheduled synchronization | Yes | Retrieve conversation, interaction, or reporting data incrementally when event coverage is incomplete or historical reconciliation is required. | Martini can schedule workflows, persist cursors or timestamps, paginate through documented endpoints, and write normalized results to downstream systems. |
| Bulk, asynchronous, and batch APIs | Not confirmed | No dedicated Ada bulk or batch API was verified. High-volume processing should use documented operations and controlled incremental workflows. | Martini can orchestrate pagination, checkpoints, queueing, and scheduled processing without assuming a dedicated Ada bulk interface. |
| File and attachment APIs | Not confirmed | No general-purpose Ada file or attachment API was verified. Availability may depend on a channel, action, or integration. | Martini can process files when an applicable Ada or intermediary endpoint is confirmed, but the integration should not assume a native Ada file API. |
| Database and analytics access | Not confirmed | Direct database access to Ada operational data was not verified. APIs or supported reporting and export mechanisms should be used instead. | Martini can connect to downstream databases for reporting or reconciliation while accessing Ada through documented APIs. |
How Ada exposes data and business events
Ada REST APIs
Ada provides authenticated REST API functionality for interacting with its conversational platform. The applicable API version, endpoint permissions, and credential model should be confirmed for each workspace and bot.
Martini implementation pattern
Martini uses a workflow to call the relevant Ada REST endpoint, validate the response, transform Ada objects into a canonical model, and route the result to an enterprise application or data store. Martini can also expose a separate REST API when another system or Ada action needs a controlled integration surface.
Implementation sequence
Ada webhooks and callbacks
Ada supports event-style and callback patterns in selected scenarios, but it should not be treated as a general-purpose webhook source for every conversation, message, knowledge, or agent event.
Martini implementation pattern
When the required Ada callback is available, Martini exposes an authenticated API or webhook workflow, verifies the inbound request using the documented mechanism, and routes the event to downstream systems. If event coverage is incomplete, a scheduled reconciliation workflow can supplement callbacks.
Implementation sequence
Ada actions and external API calls
Ada actions can connect conversational interactions to external APIs and business operations such as order lookup, account retrieval, service-request updates, or workflow initiation.
Martini implementation pattern
Martini exposes a narrow-purpose API for the Ada action or orchestrates the downstream API call behind that endpoint. The workflow validates the request, authenticates to the target system, applies authorization and business rules, and returns a constrained response suitable for the conversation.
Implementation sequence
Common Ada integration patterns
Pattern 1: Synchronize customer context to Ada
When to use this pattern
Use this pattern when Ada needs CRM or customer-platform attributes at conversation start, such as customer identifier, locale, account tier, service status, open cases, or consent indicators. The flow should minimize personal data and use a stable identity key.
Integration direction
Example Mapping
| Ada Field | Canonical Field | Target Field |
|---|---|---|
| Account.Id | customer.externalId | customerId |
| Account.CustomerTier | customer.accountTier | attributes.accountTier |
| Contact.Locale | customer.locale | locale |
| Case.Status | customer.openServiceStatus | attributes.openCaseStatus |
Martini implementation pattern
A scheduled or event-triggered Martini workflow retrieves approved customer context, validates consent and identity, maps the source fields to Ada’s customer or conversation context, and submits the result through the documented Ada API. Failed lookups are classified separately from authorization failures, and correlation data is retained for reconciliation.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- secrets management
- error handling
Pattern 2: Retrieve order status during a conversation
When to use this pattern
Use this pattern when an Ada action must provide live order, fulfillment, subscription, or account information without exposing broad downstream access to the conversational agent. The response should be narrow, authorized, and fast enough for an interactive exchange.
Integration direction
Example Mapping
| Ada Field | Canonical Field | Target Field |
|---|---|---|
| action.customerId | customer.externalId | customer.id |
| action.orderNumber | order.reference | order.name |
| order.fulfillment_status | order.status | fulfillmentStatus |
| order.updated_at | order.lastUpdated | updatedAt |
Martini implementation pattern
Ada calls a Martini API through the applicable action mechanism. Martini validates the customer and order relationship, calls Shopify with protected credentials, maps the response into a constrained Ada result, and returns a controlled not-found or unavailable response. Timeouts and transient failures are retried only where safe.
Martini capabilities used
- API exposure
- API consumption
- data mapping
- validation
- business rules
- timeouts and error handling
Pattern 3: Synchronize escalations to a service platform
When to use this pattern
Use this pattern when an Ada conversation reaches a handoff, escalation, or defined outcome and the enterprise needs a case or incident in a service platform. It is appropriate for callback-driven processing supplemented by reconciliation when Ada event coverage is incomplete.
Integration direction
Example Mapping
| Ada Field | Canonical Field | Target Field |
|---|---|---|
| conversation.id | conversation.externalId | correlationId |
| customer.id | customer.externalId | callerReference |
| escalation.reason | case.reason | shortDescription |
| resolution.status | case.status | state |
Martini implementation pattern
Martini receives the available Ada callback or processes a scheduled reconciliation result, checks the correlation key against existing ServiceNow records, maps the escalation, and creates or updates the case. Duplicate callbacks are treated as repeat deliveries, while transient ServiceNow failures are retried and permanent validation failures are routed for review.
Martini capabilities used
- webhook consumption
- API exposure
- data mapping
- idempotency
- workflow orchestration
- retry and error handling
Pattern 4: Produce scheduled conversation reporting
When to use this pattern
Use this pattern when operational or quality reporting requires normalized Ada conversation outcomes, escalation counts, deflection indicators, handoff data, timestamps, channels, or intent. It is useful when the required metrics are not available through reliable callbacks.
Integration direction
Example Mapping
| Ada Field | Canonical Field | Target Field |
|---|---|---|
| conversation.id | interaction.externalId | ada_conversation_id |
| conversation.created_at | interaction.startedAt | started_at |
| conversation.resolution | interaction.outcome | outcome |
| conversation.escalated | interaction.escalated | escalated |
Martini implementation pattern
A scheduled Martini workflow retrieves the applicable Ada data using documented pagination and an incremental checkpoint. It normalizes records, redacts or excludes sensitive transcript content, writes them to PostgreSQL or another reporting target, and records the last successful cursor or timestamp. Overlapping windows are deduplicated to protect against late-arriving data.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and checkpoints
- data mapping
- SQL integration
- privacy controls
- monitoring
Applications commonly integrated with Ada
Ada can be integrated with customer service, commerce, CRM, contact-center, and enterprise workflow products to provide conversational context, retrieve live information, and synchronize escalations or outcomes. The exact endpoint, event, and channel coverage should be validated for each deployment.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customer context, create or update cases, and provide CRM data during customer conversations. | Salesforce → Martini → Ada | Martini retrieves approved Salesforce customer and case data, maps it into Ada customer context or action responses, and synchronizes escalation outcomes back to Salesforce with correlation and duplicate checks. |
| Zendesk | Create or update support tickets when Ada escalates a conversation or requires human-agent intervention. | Ada → Martini → Zendesk | A Martini API or callback workflow receives the Ada escalation, validates the conversation identifier, transforms the payload into a Zendesk ticket, and retries transient failures without creating duplicate tickets. |
| Shopify | Retrieve order, fulfillment, and customer information during commerce-support conversations. | Shopify → Martini → Ada | An Ada action calls a Martini API, which authenticates to Shopify, retrieves narrowly scoped order data, applies customer and authorization rules, and returns a constrained response to Ada. |
| ServiceNow | Create incidents or cases from escalated conversations and return status information to Ada. | Ada → Martini → ServiceNow | Martini receives an Ada escalation or action request, maps conversation and customer identifiers to ServiceNow fields, applies routing rules, and synchronizes status updates using an idempotent correlation key. |
| Kustomer | Synchronize customer profiles, conversations, and escalation data with a customer-service platform. | Ada → Martini → Kustomer | Martini normalizes Ada conversation and customer data, checks for an existing Kustomer relationship, writes the appropriate profile or escalation data, and records downstream identifiers for reconciliation. |
| Intercom | Coordinate customer attributes, AI conversation handling, and human escalation across support channels. | Intercom → Martini → Ada | A Martini workflow retrieves or receives approved Intercom context, maps it to Ada customer attributes, and routes selected Ada outcomes back to Intercom after validation. |
| Genesys Cloud | Route escalated conversations or customer context into contact-center workflows. | Ada → Martini → Genesys Cloud | Martini transforms Ada escalation data into a Genesys Cloud handoff request, enforces authorization and routing rules, and tracks the handoff using conversation and correlation identifiers. |
| Twilio | Support SMS or telephony-related customer interactions and exchange message or status events where the Ada deployment supports the required channel. | Twilio → Martini → Ada | Martini receives or sends Twilio event data, validates channel and customer identifiers, maps messages into the applicable Ada integration surface, and handles repeat delivery through deduplication. |
How to build a Ada integration in Martini
Objective
Establish the Ada and target-system connections using the credential model confirmed for each endpoint.
Instructions in Martini
- Confirm the Ada API version, endpoint permissions, and authentication method.
- Store Ada and downstream credentials in Martini secrets or environment configuration.
- Use separate credentials and configuration for development, testing, and production.
- Define scopes or workspace, bot, action, and resource permissions narrowly.
Objective
Select the event, API, or schedule that best matches the integration’s latency and completeness requirements.
Instructions in Martini
- Use an Ada action or exposed Martini API for synchronous conversational lookups.
- Use a confirmed Ada callback for selected event-driven scenarios.
- Use a scheduler and incremental checkpoint when callback coverage is incomplete.
- Define timeout, retry, and acknowledgment behavior before implementation.
Objective
Receive or retrieve Ada data and establish the identifiers needed for correlation and reconciliation.
Instructions in Martini
- Call the documented Ada REST endpoint or receive the confirmed callback payload.
- Capture conversation, customer, message, action, and downstream correlation identifiers as applicable.
- Implement the documented pagination model and persist a cursor, timestamp, or object identifier.
- Validate required fields before calling downstream systems.
Objective
Build the Martini workflow that coordinates Ada, business systems, transformations, and response handling.
Instructions in Martini
- Separate synchronous customer-facing actions from longer-running back-office processing.
- Route requests to the appropriate CRM, commerce, service, analytics, or database operation.
- Apply conditional routing for not-found, unauthorized, validation, and transient outcomes.
- Reuse common API and transformation logic where multiple Ada flows share behavior.
Objective
Convert Ada objects and payloads into canonical and target-specific structures without losing required correlation data.
Instructions in Martini
- Map Conversations, Messages, Customers / users, and Actions using stable identifiers.
- Normalize dates, status values, locale, channel, and outcome fields.
- Minimize personal data and redact transcript content where policy requires it.
- Preserve unknown fields selectively when forward-compatible payload handling is appropriate.
Objective
Enforce authorization, identity, privacy, routing, and duplicate-prevention rules before writes or responses.
Instructions in Martini
- Confirm that the requesting customer is authorized to view the requested order, account, or case.
- Search for existing downstream cases or maintain a correlation table before creating records.
- Return constrained responses to Ada actions rather than exposing broad target-system payloads.
- Classify permanent business failures separately from transient technical failures.
Common Ada data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Conversations | Represent customer interactions handled by an Ada AI agent, including state, messages, routing, and resolution information. | Salesforce, Zendesk, ServiceNow, Kustomer, analytics platforms | Martini retrieves or receives conversation data, maps identifiers and outcomes into canonical fields, applies privacy and deduplication rules, and synchronizes it through APIs. |
| Messages | Represent individual customer or agent messages within a conversation. | Customer-service platforms, analytics platforms, contact-center systems | Martini filters and transforms message content, applies retention and redaction rules, and sends only the fields required by the target workflow. |
| Customers / users | Represent end users who interact with an Ada agent and whose identity or attributes may be passed into a conversation. | Salesforce, Shopify, Kustomer, Intercom, ServiceNow | Martini resolves stable identifiers, minimizes personal data, maps attributes into Ada context, and reconciles profile references with downstream systems. |
| AI agents / bots | Represent Ada conversational agents configured to respond to customers and execute actions. | Configuration repositories, operational reporting platforms, enterprise service systems | Martini can use documented API operations involving the relevant bot or agent, while keeping tenant, workspace, and permission configuration externalized. |
| Knowledge | Represent content and sources used by an Ada AI agent to answer customer questions. | Knowledge repositories, reporting platforms, content-management systems | Martini should process Knowledge only through confirmed Ada API or export capabilities, validate version and availability, and avoid assuming a general-purpose content API. |
| Actions | Represent configured operations that allow an Ada agent to call external systems or perform business logic. | Salesforce, Shopify, ServiceNow, Zendesk, enterprise APIs | Martini exposes controlled endpoints or consumes target APIs for actions, validates inputs, enforces authorization and business rules, and returns constrained responses. |
Authentication and security considerations
Credential handling
Ada API authentication depends on the endpoint and deployment configuration. Confirm whether the selected surface uses an API key, bearer credential, OAuth 2.0, or another mechanism before implementation.
- Store credentials in Martini secrets or environment configuration.
- Use separate credentials for development, testing, and production.
- Limit access to the required workspace, bot, action, or resource permissions.
- Verify inbound callback authentication using the mechanism documented for the Ada event.
Data protection
Conversations and messages may contain personal, account, or support information. Minimize transferred data, define transcript retention and redaction rules, and avoid placing sensitive content in logs unless permitted.
Operational considerations for Ada integrations
Reliability and throughput
- Confirm Ada request limits for the applicable API and tenant plan.
- Use explicit timeouts and exponential backoff for safe transient retries.
- Implement the documented pagination model and persist incremental checkpoints.
- Use stable identifiers and correlation tables to make callback and scheduled processing idempotent.
API and event changes
Pin integrations to a documented Ada API version where possible and monitor changes to Conversation, Message, Customer, and Action schemas. Do not assume that every lifecycle event is available as a callback.
Testing and monitoring
Test authentication, authorization, missing customers, downstream timeouts, rate limits, duplicate callbacks, and malformed payloads. Monitor Ada request identifiers, conversation identifiers, downstream correlation IDs, and Martini workflow execution IDs.
Why use Martini instead of scripts or point-to-point integrations?
More than point-to-point calls
Martini provides a maintainable workflow layer between Ada and enterprise systems. It can consume REST APIs, expose controlled APIs, receive selected callbacks, transform data, apply business rules, and coordinate synchronous and scheduled processing.
- Centralize authentication, secrets, validation, retries, and observability.
- Reuse mappings and orchestration logic across CRM, commerce, service, and analytics integrations.
- Separate conversational response paths from longer-running reconciliation and reporting workflows.
- Replace brittle scripts with governed workflows that preserve correlation, error classification, and operational visibility.
Frequently asked questions
Ada can be integrated through its authenticated REST APIs, selected event-style callbacks, and actions that call external APIs. Martini can consume Ada endpoints, expose controlled APIs for Ada actions, map conversations and customer context, and orchestrate CRM, commerce, service, analytics, and database workflows.
Yes. Martini can integrate with Ada by consuming Ada’s documented REST APIs, exposing REST APIs for Ada actions or other systems, and receiving Ada webhook-style callbacks when the required event mechanism is available. The applicable API version, permissions, and event coverage should be confirmed for the tenant.
No. A dedicated Ada connector is not required. Martini can use Ada’s native REST APIs, applicable authentication methods, action-based external API calls, and selected webhook or callback mechanisms through workflows and APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Ada. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Ada, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
REST APIs are the primary confirmed method for interacting with Ada. Actions and external API calls are appropriate for live lookups and business operations, while callbacks can support selected event-driven scenarios after tenant-specific confirmation. No official Ada GraphQL or SOAP API was confirmed.
Ada supports event-style and callback patterns in selected scenarios, but coverage is not confirmed for every conversation, message, knowledge, or agent event. Validate the required event and use scheduled reconciliation when callback coverage is incomplete.
Martini can synchronize customer context, conversations, messages, escalations, and reporting data through API-led, callback-driven, or scheduled workflows. Stable identifiers, pagination checkpoints, incremental windows, and correlation tables help maintain consistency and prevent duplicate writes.
Martini maps Ada objects into canonical and target-specific models, applies validation and business rules, and classifies authentication, rate-limit, validation, not-found, transient, and downstream errors. Workflows can retry safe transient failures, log correlation identifiers, and deduplicate callbacks using conversation or external keys.
Related Martini documentation
APIs
Connect Ada with your enterprise systems
Use Martini to build governed Ada integrations across customer context, conversational actions, escalations, and operational reporting.