AI Plugin for Bitrix24: Automate CRM with Neural Networks

Your CRM manager spends 25 minutes filling out a deal card after each call? Commercial proposals are generated from templates, and conversion suffers due to generic emails? This is a typical picture in sales departments using Bitrix24, where routine eats up time for real negotiations.

We are a team of AI/ML engineers with over 5 years of experience integrating neural networks into CRM. Our approach: not just attaching an "AI feature," but embedding it into workflows so that the manager feels no friction. Result: operational cost reduction by 80% and conversion increase by 12%.

Why Embed an AI Plugin Directly into Bitrix24?

Ready-made AI assistants (SalesGPT, Gong) do not integrate with Russian CRM. Bitrix24 is a flexible platform: through REST API, Placement, and Events, you can add any logic. The challenge: the complexity of developing the AI layer—from LLM selection to latency optimization. We address this with four modules:

How We Implement the AI Plugin

Each plugin is built modularly. Stack: Python + Anthropic/OpenAI API, deployment via Docker + Bitrix24 Placement. Webhook handler code:

# webhook_handler.py — processing Bitrix24 events
from flask import Flask, request, jsonify
from anthropic import Anthropic
import requests

app = Flask(__name__)
client = Anthropic()

BITRIX_URL = "https://your-domain.bitrix24.ru/rest"
BITRIX_TOKEN = "your-webhook-token"

def bitrix_api(method: str, params: dict) -> dict:
    """Call Bitrix24 REST API"""
    response = requests.post(
        f"{BITRIX_URL}/{BITRIX_TOKEN}/{method}/",
        json=params,
    )
    return response.json().get("result", {})

@app.route("/webhook/call-ended", methods=["POST"])
def on_call_ended():
    """Handler for call end event"""
    data = request.json
    call_id = data.get("data", {}).get("CALL_ID")
    crm_entity_id = data.get("data", {}).get("CRM_ENTITY_ID")

    # Get call transcript
    call_info = bitrix_api("voximplant.statistic.get", {"CALL_ID": call_id})
    transcript = call_info.get("TRANSCRIPT", "")

    if not transcript:
        return jsonify({"status": "no transcript"})

    # AI summarization
    summary = summarize_call(transcript)

    # Record in CRM as activity
    bitrix_api("crm.activity.add", {
        "fields": {
            "OWNER_TYPE_ID": 2,  # 2 = Contact, 3 = Company
            "OWNER_ID": crm_entity_id,
            "TYPE_ID": 6,  # Call
            "SUBJECT": "Call summarization (AI)",
            "DESCRIPTION": summary["text"],
            "DESCRIPTION_TYPE": 1,
        }
    })

    # Extract key data and update deal fields
    if crm_entity_id:
        updates = extract_crm_fields(transcript)
        if updates:
            bitrix_api("crm.deal.update", {
                "id": crm_entity_id,
                "fields": updates,
            })

    return jsonify({"status": "ok"})

def summarize_call(transcript: str) -> dict:
    """Summarize call transcript"""
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=1024,
        system="""Summarize sales negotiations.
Format:
- Brief summary (2-3 sentences)
- Key agreements
- Next steps
- Client objections""",
        messages=[{
            "role": "user",
            "content": f"Transcript:\n{transcript}"
        }]
    )
    return {"text": response.content[0].text}

def extract_crm_fields(transcript: str) -> dict:
    """Extract data for updating CRM fields"""
    import json

    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=512,
        messages=[{
            "role": "user",
            "content": f"""Extract data from conversation for CRM.
Return JSON: {{
  "TITLE": "deal title if mentioned",
  "OPPORTUNITY": number (budget if mentioned),
  "COMMENTS": "important notes"
}}
If field not mentioned — do not include it.

Conversation: {transcript[:2000]}"""
        }]
    )

    text = response.content[0].text
    try:
        return json.loads(text[text.find("{"):text.rfind("}") + 1])
    except Exception:
        return {}

UI Placement — embedding into deal card

// placement.js — embedded widget in CRM card
BX24.init(function() {
    // Button "AI Analysis" in deal card
    BX24.placement.bind('CRM_DEAL_DETAIL_TAB', {
        title: 'AI Assistant',
        onClick: function() {
            showAIPanel();
        }
    });
});

async function generateCommercialProposal(dealId) {
    // Get deal data
    const deal = await BX24.callMethod('crm.deal.get', { id: dealId });

    // Request proposal generation
    const response = await fetch('/ai/generate-proposal', {
        method: 'POST',
        body: JSON.stringify({ deal: deal.result }),
        headers: { 'Content-Type': 'application/json' }
    });

    const result = await response.json();

    // Insert proposal into description field
    await BX24.callMethod('crm.deal.update', {
        id: dealId,
        fields: { COMMENTS: result.proposal }
    });
}

Commercial Proposal Generation

@app.route("/ai/generate-proposal", methods=["POST"])
def generate_proposal():
    deal = request.json.get("deal", {})

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        system="""You are a B2B sales manager.
Create professional commercial proposals based on deal data.""",
        messages=[{
            "role": "user",
            "content": f"""Create a proposal for the client.
Deal data:
- Title: {deal.get('TITLE')}
- Client: {deal.get('COMPANY_ID')}
- Amount: {deal.get('OPPORTUNITY')} {deal.get('CURRENCY_ID')}
- Comments: {deal.get('COMMENTS', '')}

Proposal structure: greeting, understanding of problem, proposed solution, benefits, cost, next step."""
        }]
    )

    return jsonify({"proposal": response.content[0].text})

Which LLM Models Are Optimal for Different Tasks?

Model selection is critical for balancing speed and quality. For call summarization we use Claude Haiku — it is 3x faster than Sonnet and 5x cheaper, while key field extraction quality drops by less than 5%. For proposal generation, where depth and personalization matter, we use Claude Sonnet or GPT-4o. Internal tests showed that with the same API budget, the Haiku + Sonnet combination processes 40% more calls than using one expensive model.

Practical Case: Sales Department of 15 Managers (from our practice)

Client — an IT equipment distributor. Each manager spent 30–40 minutes after a call filling CRM and composing summaries. Conversion of sent proposals was 18% (too template-like).

We implemented three modules: call summarization, automatic deal field updates, and proposal generation. After two weeks of use:

• Post-call processing time: 30 min → 5 min (83% operational cost reduction)
• Conversion of sent proposals: 18% → 30% (gain due to personalization)
• Errors in filling fields (budget, date) — 12 per day → 0
• Managers could handle 3 more negotiations per day

Head of Sales Department: "We expected time savings, but didn't expect such conversion growth. Now proposals truly engage clients."

What's Included in the Work

• Audit of current business processes in Bitrix24
• Designing AI module architecture (LLM selection, prompt tuning, RAG schemes)
• Developing webhooks and Placement widgets
• Integration with telephony (VoxImplant, Mango Office)
• Configuring proposal generation for your product line
• Testing on real data (at least 50 transactions)
• Publication in Marketplace or installation on your server
• Operation documentation and administrator training

Work Process

1. Analytics (1-2 days): study deal schemas, fields, events. Identify AI insertion points.
2. Design (2-3 days): select models, draw architecture, agree on scenarios.
3. Development (3-7 days): write code, embed widgets, configure webhooks.
4. Testing (2-3 days): run on historical data, fix errors, optimize latency to p99 < 2s.
5. Deployment and training (1-2 days): roll out to production, train administrators, hand over documentation.

Indicative Timeline

Final cost is calculated individually for your process. Leave a request — we will assess the project for free and offer the optimal solution.

We guarantee quality: certified Bitrix24 engineers, over 5 years of experience, more than 20 successful integrations. Our solutions undergo code review and load testing. Contact us to get a consultation and see a demo on your data.