Docs
Integrations
Overview

Integrations Overview

AgenticAnts integrates seamlessly with your existing AI stack. Connect your favorite frameworks, no-code tools, and enterprise systems.

Integration Categories

Developer SDKs

Build custom integrations with our SDKs:

JavaScript/TypeScriptPythonJavaOpenTelemetry

AI Frameworks

Auto-instrument popular AI frameworks:

LangChainLlamaIndexAutoGenSemantic KernelHaystack

No-Code Builders

Connect visual AI builders:

FlowiseLangflowDify.AIn8nLobeChat

AI Gateways

Integrate with LLM gateways:

OpenRouterLiteLLM

Enterprise Tools

Connect with your enterprise stack:

JIRASlack

Quick Start Examples

JavaScript with LangChain

import { AgenticAnts } from '@agenticants/sdk'
import { ChatOpenAI } from 'langchain/chat_models/openai'
import { AgenticAntsCallbackHandler } from '@agenticants/langchain'
 
const ants = new AgenticAnts({ apiKey: process.env.AGENTICANTS_API_KEY })
 
const llm = new ChatOpenAI({
  callbacks: [new AgenticAntsCallbackHandler(ants)]
})
 
// All LLM calls automatically traced!
const response = await llm.call([
  { role: 'user', content: 'What is AI?' }
])

Python with AutoGen

from agenticants import AgenticAnts
from agenticants.integrations import autogen
import autogen as ag
 
ants = AgenticAnts(api_key=os.getenv('AGENTICANTS_API_KEY'))
autogen.instrument(ants)
 
# All AutoGen agents automatically traced!
agent = ag.AssistantAgent(
    name="assistant",
    llm_config={"model": "gpt-4"}
)

Java with Spring Boot

import com.ants.platform.client.AntsPlatformClient;
 
@Service
public class AgentService {
    private final AntsPlatformClient client;
 
    public AgentService() {
        this.client = AntsPlatformClient.builder()
            .url("https://api.agenticants.ai")
            .credentials(
                System.getenv("ANTS_PLATFORM_PUBLIC_KEY"),
                System.getenv("ANTS_PLATFORM_SECRET_KEY")
            )
            .build();
    }
 
    // All agent operations automatically traced!
    public String processQuery(String query) {
        // Your agent logic here
    }
}

No-Code with Flowise

# In Flowise, add AgenticAnts node:
1. Drag "AgenticAnts" node to canvas
2. Connect to your flow
3. Configure API key
4. All flows automatically monitored!

Integration Benefits

Automatic Instrumentation

Most integrations provide zero-code instrumentation:

# Just enable the integration
from agenticants.integrations import langchain
 
langchain.auto_instrument()
 
# Now all LangChain calls are automatically traced!
from langchain import OpenAI
llm = OpenAI()
llm("Hello")  #  Automatically traced

Comprehensive Coverage

Track everything:

  • LLM calls - Model, tokens, cost, latency
  • Vector searches - Queries, results, embeddings
  • Tool usage - Function calls and outputs
  • Agent decisions - Reasoning and actions
  • Multi-agent interactions - Collaboration flows

Rich Context

Integrations capture framework-specific data:

// LangChain callback provides:
{
  chain_type: 'ConversationalRetrievalChain',
  retriever_docs: 5,
  prompt_template: '...',
  llm_output: {...},
  memory_messages: [...]
}
 
// AutoGen integration provides:
{
  agent_name: 'coder',
  message_type: 'code_execution',
  conversation_history: [...],
  code_executed: '...',
  execution_result: '...'
}

Choosing an Integration

Start with SDKs

For full control and customization:

  • JavaScript/TypeScript SDK - Web apps, Node.js services
  • Python SDK - Data science, ML pipelines
  • Java SDK - Enterprise applications, Spring Boot services
  • OpenTelemetry - Multi-language, standardized

Use Framework Integrations

For quick setup with existing code:

  • LangChain - Most popular LLM framework
  • LlamaIndex - RAG and data apps
  • AutoGen - Multi-agent systems

Try No-Code Tools

For rapid prototyping:

  • Flowise - Visual flow builder
  • Langflow - Drag-and-drop interfaces
  • Dify.AI - Complete platform

Migration Paths

From OpenAI to AgenticAnts

// Before
import OpenAI from 'openai'
const openai = new OpenAI()
const response = await openai.chat.completions.create({...})
 
// After - Add AgenticAnts with one line
import { AgenticAnts } from '@agenticants/sdk'
import OpenAI from 'openai'
 
const ants = new AgenticAnts({ apiKey: process.env.AGENTICANTS_API_KEY })
const openai = ants.wrap(new OpenAI())  // Automatically traced!
 
const response = await openai.chat.completions.create({...})

From LangSmith to AgenticAnts

# Before - LangSmith
from langsmith import Client
client = Client()
 
# After - AgenticAnts (drop-in replacement)
from agenticants import AgenticAnts
from agenticants.integrations import langchain
 
ants = AgenticAnts(api_key=os.getenv('AGENTICANTS_API_KEY'))
langchain.auto_instrument()  # Same API, better insights!

Integration Support

Community Support

Enterprise Support

  • Dedicated support team
  • Custom integrations built for you
  • Migration assistance from other platforms
  • Training and onboarding

Request an Integration

Don't see your tool? Let us know!

# Via CLI
ants integrations request --tool "YourTool" --priority high
 
# Via API
curl -X POST https://api.agenticants.ai/v1/integrations/requests \
  -H "Authorization: Bearer $API_KEY" \
  -d '{"tool": "YourTool", "use_case": "..."}'

Next Steps

Choose your integration and get started:

Model Versioning & DeploymentPython SDK