Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Ziņojumi par konkurenci automatizētā režīmā

Nodarbība 10 no 12 Atjaunota 2026. gada 30. jūlijs Vidējs
Šajā lapā
  1. Konkurences izlūkošanas automatizācija
  2. Pilnīga konkurences ziņojuma arhitektūra
  3. Ziņošanas sistēmas izveide
  4. Ziņojuma strukturēšana lietojamā JSON formātā
  5. Periodu salīdzināšana pārmaiņu noteikšanai
  6. Atkārtotas izpildes plānošana
  7. Labākā prakse lietojamu ziņojumu veidošanai
  8. Galvenās atziņas

Konkurences izlūkošanas automatizācija

Vienreizējs ziņojums par konkurenci zaudē aktuālityāti dažu dienu laikā. Patiesā vērtība slēpjas automatizācijā: regulāri ģenerēti ziņojumi ar identisku struktūru, kas ļauj salīdzināt periodus un izsekot konkurentu stratēģiskajām pārmaiņām.

Šajā nodarbībā tu uzzināsi, kā izveidot automatizētu konkurences ziņošanas sistēmu, kas apvieno datus no X un tīmekļa.

Pilnīga konkurences ziņojuma arhitektūra

Efektīvs mārketinga konkurences ziņojums aptver piecas asis, un to vērtība izriet no to savstarpējās mijiedarbības: produkta laišana tirgū (3. ass) atspoguļojas arī publikāciju apjomā (1. ass) un sabiedrības noskaņojumā (4. ass). Tieši šī krusteniskā analīze atšķir izlūkošanu no vienkāršas datu vākšanas — signāls, ko apstiprina divas asis, ir pelnījis uzmanību, savukārt izolēts signāls prasa papildu pārbaudi:

1. Aktivitāte sociālajos tīklos

Publikāciju apjoms, izmantotie formāti, iesaiste, auditorijas pieaugums.

2. Satura stratēģija

Aptvertās tēmas, tonis, pozicionējums, novērotais redakcijas kalendārs.

3. Laišanas tirgū un paziņojumi

Jauni produkti, funkcijas, partnerības, pasākumi.

4. Sabiedrības uztvere

Noskaņojums, sūdzības, slavēšana, spontāni salīdzinājumi ar citiem zīmoliem.

5. Cenu piedāvājuma un pozicionējuma analīze

Cenu izmaiņas, akcijas, iepakojums, īpašie piedāvājumi.

Ziņošanas sistēmas izveide

Konkurences ziņojuma klase

from datetime import datetime, timedelta
import json

class RapportConcurrentiel:
    def __init__(self, client, marque_propre, concurrents):
        self.client = client
        self.marque = marque_propre
        self.concurrents = concurrents

    def collecter_donnees_x(self, handles, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Collect and analyze posts
            from these accounts from {start} to {end}.

            Provide for each account:
            - Estimated number of posts
            - Content types (text, image, video, thread)
            - Most engaging posts
            - Main themes covered
            - Observed tone and positioning
            - Detected announcements or launches""",
            tools=[{
                "type": "x_search",
                "allowed_x_handles": handles,
                "from_date": start,
                "to_date": end,
                "enable_image_understanding": True
            }]
        )
        return response.output_text

    def collecter_donnees_web(self, concurrent, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Search for recent news regarding
            {concurrent} between {start} and {end}.

            Focus on:
            - Press releases and news articles
            - Product or service updates
            - Leadership team changes
            - Fundraising or financial results
            - Strategic partnerships""",
            tools=[{
                "type": "web_search",
                "allowed_domains": [
                    "techcrunch.com", "lesechos.fr",
                    "usine-digitale.fr"
                ]
            }]
        )
        return response.output_text

Kompilētā ziņojuma ģenerēšana

    def generer_rapport(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        sections = {}

        # Datu vākšana katram konkurentam
        for concurrent in self.concurrents:
            handles = concurrent.get("handles", [])
            nom = concurrent["nom"]

            donnees_x = self.collecter_donnees_x(
                handles, start, end
            ) if handles else "No X data"

            donnees_web = self.collecter_donnees_web(
                nom, start, end
            )

            sections[nom] = {
                "x": donnees_x,
                "web": donnees_web
            }

        # Salīdzinošs kopsavilkums
        rapport_final = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Compile this monthly competitive report.

            Our brand: {self.marque}
            Period: {start} to {end}

            DATA PER COMPETITOR:
            {json.dumps(sections, ensure_ascii=False, indent=2)}

            Report structure:
            1. EXECUTIVE SUMMARY (5 bullet points max)
            2. COMPARATIVE TABLE (activity, sentiment, innovation)
            3. ANALYSIS PER COMPETITOR (strengths, weaknesses, moves)
            4. IDENTIFIED THREATS (ranked by urgency)
            5. OPPORTUNITIES FOR {self.marque}
            6. STRATEGIC RECOMMENDATIONS (3-5 priority actions)"""
        ).output_text

        return rapport_final

Ziņojuma strukturēšana lietojamā JSON formātā

Lai aizpildītu informācijas paneli vai datubāzi, pieprasīti strukturētu formātu:

    def rapport_json(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Generate a competitive report in JSON.

            Competitors: {json.dumps([c['nom'] for c in self.concurrents])}
            Period: {start} to {end}

            Expected format:
            {{
              "period": "{start} - {end}",
              "competitors": [
                {{
                  "name": "Competitor A",
                  "social_activity": {{
                    "post_volume": 45,
                    "average_engagement": "high",
                    "dominant_formats": ["image", "thread"]
                  }},
                  "public_sentiment": 3.8,
                  "innovations": ["description"],
                  "threats": ["description"],
                  "main_strength": "description",
                  "main_weakness": "description"
                }}
              ],
              "recommendations": ["action 1", "action 2"]
            }}""",
            tools=[
                {"type": "x_search", "from_date": start, "to_date": end},
                {"type": "web_search"}
            ]
        )
        return response.output_text

Periodu salīdzināšana pārmaiņu noteikšanai

Automatizētas sistēmas vērtība slēpjas laika gaitā veiktajā salīdzinājumā:

def comparer_rapports(rapport_actuel, rapport_precedent):
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=f"""Compare these two consecutive
        competitive reports and identify significant changes:

        PREVIOUS REPORT: {rapport_precedent}
        CURRENT REPORT: {rapport_actuel}

        Analysis:
        1. Which competitors changed strategy?
        2. What new threats appeared?
        3. What opportunities opened or closed?
        4. What trends are confirmed or reversing?
        5. Recommended immediate actions."""
    )
    return response.output_text

Atkārtotas izpildes plānošana

Integrē savu ziņojumu cron uzdevumā vai Python plānotājā:

# Iknedēļas izpilde
rapport = RapportConcurrentiel(
    client=client,
    marque_propre="Your Brand",
    concurrents=[
        {
            "nom": "Competitor A",
            "handles": ["competitor_a", "competitor_a_fr"]
        },
        {
            "nom": "Competitor B",
            "handles": ["competitor_b"]
        },
        {
            "nom": "Competitor C",
            "handles": ["competitor_c"]
        }
    ]
)

# Iknedēļas ziņojums
resultat = rapport.generer_rapport(periode_jours=7)

# Ziņojuma arhivēšana
with open(f"reports/competitor_{datetime.now().strftime('%Y-%m-%d')}.md",
          "w") as f:
    f.write(resultat)

Labākā prakse lietojamu ziņojumu veidošanai

  • Konsekvence: vienmēr izmanto vienu un to pašu struktūru, lai atvieglotu salīdzināšanu.
  • Prioritāšu noteikšana: rangē atziņas pēc to ietekmes uz biznesu, nevis pēc apjoma.
  • Rīcības virzītspēja: katrai sadaļai jāved pie konkrēta ieteikuma.
  • Izplatīšana: pielāgo formātu saņēmējam (vadība = kopsavilkums, operatīvā vadība = detalizēta informācija).
  • Arhivēšana: glabā visus ziņojumus, lai veiktu ilgtermiņa tendenču analīzi.

Galvenās atziņas

  • Automatizēts konkurences ziņojums aptver 5 asis: sociālie tīkli, saturs, laišanas tirgū, uztvere, cenas.
  • Apvieno X Search un Web Search, lai iegūtu pilnīgu priekšstatu par katru konkurentu.
  • Strukturē rezultātus JSON formātā, lai aizpildītu savus informācijas panelus.
  • Salīdzinājums starp periodiem atklāj stratēģiskas pārmaiņas.
  • Katrai atziņai jāved pie rīcībā liekama ieteikuma.
  • Sistemātiski arhivē savus ziņojumus ilgtermiņa izsekošanai.