Csm Kb Generation

Knowledge Article Generation from CSM Cases

Overview

This skill generates polished knowledge base articles from resolved customer service cases. It transforms internal case resolution data into customer-facing documentation that can deflect future cases and empower self-service. It covers:

• Extracting resolution steps, root cause, and workarounds from resolved CSM cases
• Structuring articles with customer-friendly language, removing internal jargon
• Inserting screenshot placeholders with descriptive alt text for visual guidance
• Generating FAQ sections based on common follow-up questions from similar cases
• Categorizing and tagging articles for optimal searchability
• Publishing articles through the knowledge workflow for review and approval

When to use: After resolving a CSM case that addresses a common or recurring issue, when knowledge gaps are identified during case handling, or during periodic knowledge harvesting from closed case data.

Value proposition: Converts tribal knowledge locked in case resolutions into reusable self-service content. Reduces case volume by enabling customers to find answers independently and ensures consistent resolution guidance across the support team.

Prerequisites

• Plugins: Customer Service Management (com.sn_customerservice), Knowledge Management (com.glideapp.knowledge)
• Roles: knowledge_admin, knowledge_manager, or knowledge (for article creation); sn_customerservice_agent (for case access)
• Access: Read access to sn_customerservice_case, interaction, csm_consumer, sys_journal_field; read/write access to kb_knowledge, kb_knowledge_base, kb_category
• Knowledge: Understanding of your organization's knowledge base structure, article templates, and publishing workflows

Procedure

Step 1: Identify Candidate Cases for KB Generation

Query resolved cases that are good candidates for knowledge articles based on frequency, category, and resolution quality.

Using MCP (Claude Code/Desktop):

Tool: SN-Query-Table
Parameters:
  table_name: sn_customerservice_case
  query: state=3^resolution_codeISNOTEMPTY^closed_atONLast 30 days@javascript:gs.beginningOfLast30Days()@javascript:gs.endOfLast30Days()^ORDERBYDESCclosed_at
  fields: sys_id,number,short_description,category,subcategory,resolution_code,resolved_by,product,close_notes,opened_at,closed_at
  limit: 20

Using REST API:

GET /api/now/table/sn_customerservice_case?sysparm_query=state=3^resolution_codeISNOTEMPTY^closed_atONLast 30 days@javascript:gs.beginningOfLast30Days()@javascript:gs.endOfLast30Days()^ORDERBYDESCclosed_at&sysparm_fields=sys_id,number,short_description,category,subcategory,resolution_code,resolved_by,product,close_notes,opened_at,closed_at&sysparm_limit=20&sysparm_display_value=true

Step 2: Extract Full Resolution Details from the Case

Retrieve the complete case record including close notes, work notes, and resolution information.

Using MCP:

Tool: SN-Read-Record
Parameters:
  table_name: sn_customerservice_case
  sys_id: [case_sys_id]
  fields: sys_id,number,short_description,description,state,category,subcategory,resolution_code,close_notes,cause,product,contact_type,opened_at,closed_at,resolved_by

Then retrieve work notes for step-by-step resolution context:

Tool: SN-Query-Table
Parameters:
  table_name: sys_journal_field
  query: element_id=[case_sys_id]^elementINwork_notes,comments^ORDERBYsys_created_on
  fields: sys_id,element,value,sys_created_on,sys_created_by
  limit: 30

Using REST API:

GET /api/now/table/sn_customerservice_case/{case_sys_id}?sysparm_fields=sys_id,number,short_description,description,state,category,subcategory,resolution_code,close_notes,cause,product,contact_type,opened_at,closed_at,resolved_by&sysparm_display_value=true

GET /api/now/table/sys_journal_field?sysparm_query=element_id=[case_sys_id]^elementINwork_notes,comments^ORDERBYsys_created_on&sysparm_fields=sys_id,element,value,sys_created_on,sys_created_by&sysparm_limit=30

Step 3: Find Similar Resolved Cases for FAQ Generation

Query related cases to identify common follow-up questions and alternative resolutions.

Using MCP:

Tool: SN-Query-Table
Parameters:
  table_name: sn_customerservice_case
  query: category=[case_category]^subcategory=[case_subcategory]^state=3^sys_id!=[case_sys_id]^ORDERBYDESCclosed_at
  fields: sys_id,number,short_description,close_notes,resolution_code,description
  limit: 10

Using REST API:

GET /api/now/table/sn_customerservice_case?sysparm_query=category=[case_category]^subcategory=[case_subcategory]^state=3^sys_id!=[case_sys_id]^ORDERBYDESCclosed_at&sysparm_fields=sys_id,number,short_description,close_notes,resolution_code,description&sysparm_limit=10&sysparm_display_value=true

Step 4: Check for Existing Knowledge Articles

Search for duplicate or related articles to avoid redundancy.

Using MCP:

Tool: SN-NL-Search
Parameters:
  query: [case_short_description]
  table: kb_knowledge
  limit: 5

Using REST API:

GET /api/now/table/kb_knowledge?sysparm_query=short_descriptionLIKE[key_terms]^workflow_stateINpublished,draft&sysparm_fields=sys_id,number,short_description,workflow_state,sys_view_count,kb_knowledge_base&sysparm_limit=5&sysparm_display_value=true

Step 5: Identify the Target Knowledge Base and Category

Determine where the article should be published.

Using MCP:

Tool: SN-Query-Table
Parameters:
  table_name: kb_knowledge_base
  query: active=true
  fields: sys_id,title,description,owner,kb_version
  limit: 10

Tool: SN-Query-Table
Parameters:
  table_name: kb_category
  query: kb_knowledge_base=[kb_sys_id]^active=true
  fields: sys_id,label,parent_id,full_category
  limit: 20

Using REST API:

GET /api/now/table/kb_knowledge_base?sysparm_query=active=true&sysparm_fields=sys_id,title,description,owner&sysparm_limit=10&sysparm_display_value=true

GET /api/now/table/kb_category?sysparm_query=kb_knowledge_base=[kb_sys_id]^active=true&sysparm_fields=sys_id,label,parent_id,full_category&sysparm_limit=20&sysparm_display_value=true

Step 6: Generate and Create the Knowledge Article

Compose the article with customer-facing language and create it in ServiceNow.

Using MCP:

Tool: SN-Create-Record
Parameters:
  table_name: kb_knowledge
  fields:
    short_description: "How to Resolve Online Return Processing Errors"
    kb_knowledge_base: [kb_sys_id]
    kb_category: [category_sys_id]
    text: |
      Problem
      When attempting to process a return through the online portal, you may encounter an error message stating "Unable to process return" or the page may time out during submission.

      Cause
      This issue occurs when the browser session expires during the return process, typically after being idle for more than 15 minutes on the return form.

      Resolution
      
        Clear your browser cache and cookies for the portal domain
        Log out and log back in to establish a fresh session
        Navigate to My Orders > Returns
        
        Select the order containing the item(s) to return
        Click Start Return and complete the form within 10 minutes
        
        Submit the return request and note the confirmation number
        
      

      If the Issue Persists
      If you continue to experience errors after following the steps above:
      
        Try using a different browser (Chrome, Firefox, or Edge recommended)
        Disable browser extensions that may interfere with the portal
        Contact support with your order number and the error message
      

      Frequently Asked Questions
      Q: Will I lose my return information if the page times out?
      A: Yes, you will need to re-enter the return details. The system does not save partial return submissions.

      Q: Can I process returns through the mobile app instead?
      A: Yes, the mobile app maintains a longer session and is recommended for complex returns with multiple items.

      Q: How long does the return take to process after submission?
      A: Returns are typically processed within 3-5 business days. You will receive an email confirmation when the return is approved.
    workflow_state: draft
    article_type: text
    valid_to: "2027-03-19"
    source: case_resolution

Using REST API:

POST /api/now/table/kb_knowledge
Content-Type: application/json

{
  "short_description": "How to Resolve Online Return Processing Errors",
  "kb_knowledge_base": "[kb_sys_id]",
  "kb_category": "[category_sys_id]",
  "text": "ProblemWhen attempting to process a return...",
  "workflow_state": "draft",
  "article_type": "text",
  "source": "case_resolution"
}

Step 7: Link the Article to the Source Case

Associate the new article with the originating case for traceability.

Using MCP:

Tool: SN-Create-Record
Parameters:
  table_name: m2m_kb_task
  fields:
    kb_knowledge: [article_sys_id]
    task: [case_sys_id]

Using REST API:

POST /api/now/table/m2m_kb_task
Content-Type: application/json

{
  "kb_knowledge": "[article_sys_id]",
  "task": "[case_sys_id]"
}

Tool Usage

MCP Tools Reference

| Tool | When to Use | |------|-------------| | SN-NL-Search | Find existing KB articles semantically matching the case topic | | SN-Query-Table | Query resolved cases, work notes, KB bases, and categories | | SN-Read-Record | Retrieve full case details by sys_id | | SN-Create-Record | Create the KB article and case-article association | | SN-Update-Record | Update article content or workflow state | | SN-Execute-Background-Script | Batch-generate articles from multiple resolved cases |

REST API Reference

| Endpoint | Method | Purpose | |----------|--------|---------| | /api/now/table/sn_customerservice_case | GET | Query resolved cases for article candidates | | /api/now/table/sys_journal_field | GET | Retrieve work notes with resolution steps | | /api/now/table/kb_knowledge | GET/POST/PATCH | Search, create, and update knowledge articles | | /api/now/table/kb_knowledge_base | GET | List available knowledge bases | | /api/now/table/kb_category | GET | Browse knowledge categories | | /api/now/table/kb_feedback | GET | Check article feedback for improvement |

Best Practices

• Use customer-facing language: Replace internal jargon, case references, and technical shorthand with clear language the customer can follow
• Structure consistently: Use Problem > Cause > Resolution > FAQ format for all generated articles
• Include screenshot placeholders: Mark visual guidance locations with `` for content teams to fill in
• Generate FAQs from case patterns: Analyze similar resolved cases to build FAQ sections that address common follow-up questions
• Set expiration dates: Add valid_to dates to trigger periodic review and ensure article accuracy
• Avoid exposing internal details: Never include agent names, internal escalation paths, or system architecture details in customer-facing articles
• Tag with products and versions: Use metadata fields to associate articles with specific products and versions for targeted search results
• Submit as draft: Always create articles in draft state for review before publishing to maintain quality standards

Troubleshooting

"Article content is too technical"

Cause: Work notes often contain technical shorthand intended for internal teams. Solution: Post-process the generated text to replace technical terms. Use a glossary mapping (e.g., "GlideRecord" -> "database query", "BR" -> "automated rule") before composing the article.

"Duplicate article detected"

Cause: A knowledge article covering the same topic already exists. Solution: Compare the existing article with the new resolution. If the new case provides additional context, update the existing article rather than creating a duplicate.

"No close notes available"

Cause: The resolving agent did not populate close notes on the case. Solution: Fall back to work notes to reconstruct the resolution steps. Filter work notes for resolution-related content by looking for keywords like "resolved", "fixed", "solution", "workaround".

"FAQ section is empty"

Cause: No similar cases found to extract common questions from. Solution: Generate generic FAQs based on the article category (e.g., "How long does this take?", "What if this doesn't work?", "Who do I contact for help?").

Examples

Example 1: Generate Article from a Single Resolved Case

Scenario: Case CS0045678 resolved a recurring login issue.

Tool: SN-Read-Record
Parameters:
  table_name: sn_customerservice_case
  sys_id: [case_sys_id]
  fields: number,short_description,description,close_notes,resolution_code,category,product

Generated article structure:

• Title: "How to Fix Login Failures After Password Reset"
• Problem: Description of the login error symptoms
• Cause: Password policy sync delay between identity provider and portal
• Resolution: Step-by-step fix with screenshot placeholders
• FAQ: 3 questions from 8 similar resolved cases

Example 2: Batch Generate Articles from Case Category

Scenario: Generate articles for all resolved cases in the "Billing" category from the last 30 days.

Tool: SN-Query-Table
Parameters:
  table_name: sn_customerservice_case
  query: category=billing^state=3^closed_atONLast 30 days@javascript:gs.beginningOfLast30Days()@javascript:gs.endOfLast30Days()^close_notesISNOTEMPTY
  fields: sys_id,number,short_description,close_notes,resolution_code
  limit: 50

Group cases by subcategory, then generate one consolidated article per subcategory covering the most common resolutions.

Example 3: Enrich Existing Article with New Case Data

Scenario: An existing KB article needs updated resolution steps based on a newly resolved case.

Tool: SN-Query-Table
Parameters:
  table_name: kb_knowledge
  query: number=KB0045123
  fields: sys_id,short_description,text,workflow_state
  limit: 1

Tool: SN-Update-Record
Parameters:
  table_name: kb_knowledge
  sys_id: [article_sys_id]
  fields:
    text: [updated_html_content_with_new_resolution_steps]
    workflow_state: draft

Related Skills

• csm/case-summarization - Summarize cases for context before KB generation
• csm/resolution-notes - Generate structured resolution notes on case closure
• csm/suggested-steps - Generate resolution steps that can seed KB content
• knowledge/content-recommendation - Recommend existing articles to avoid duplication
• knowledge/article-optimization - Optimize article searchability and quality

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Happy-Technologies-LLC
• Source: Happy-Technologies-LLC/happy-platform-skills
• License: Apache-2.0

Install and usage instructions live in the source repository linked above.