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