| name | csm-kb-generation |
| version | 1.0.0 |
| description | Generate knowledge articles from resolved CSM cases with customer-facing language, structured content, screenshot placeholders, and FAQ sections |
| author | Happy Technologies LLC |
| tags | ["csm","knowledge","kb-generation","case-resolution","customer-facing","faq","documentation"] |
| platforms | ["claude-code","claude-desktop","chatgpt","cursor","any"] |
| tools | {"mcp":["SN-NL-Search","SN-Query-Table","SN-Read-Record","SN-Create-Record","SN-Update-Record","SN-Execute-Background-Script"],"rest":["/api/now/table/sn_customerservice_case","/api/now/table/interaction","/api/now/table/csm_consumer","/api/now/table/kb_knowledge","/api/now/table/kb_knowledge_base","/api/now/table/kb_category","/api/now/table/sys_journal_field","/api/now/table/kb_feedback"],"native":["Bash"]} |
| complexity | intermediate |
| estimated_time | 15-30 minutes |
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: |
<h2>Problem</h2>
<p>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.</p>
<h2>Cause</h2>
<p>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.</p>
<h2>Resolution</h2>
<ol>
<li>Clear your browser cache and cookies for the portal domain</li>
<li>Log out and log back in to establish a fresh session</li>
<li>Navigate to <strong>My Orders > Returns</strong></li>
<!-- [SCREENSHOT: Navigation to Returns page showing My Orders menu] -->
<li>Select the order containing the item(s) to return</li>
<li>Click <strong>Start Return</strong> and complete the form within 10 minutes</li>
<!-- [SCREENSHOT: Start Return button highlighted on the order detail page] -->
<li>Submit the return request and note the confirmation number</li>
<!-- [SCREENSHOT: Return confirmation page with confirmation number] -->
</ol>
<h2>If the Issue Persists</h2>
<p>If you continue to experience errors after following the steps above:</p>
<ul>
<li>Try using a different browser (Chrome, Firefox, or Edge recommended)</li>
<li>Disable browser extensions that may interfere with the portal</li>
<li>Contact support with your order number and the error message</li>
</ul>
<h2>Frequently Asked Questions</h2>
<p><strong>Q: Will I lose my return information if the page times out?</strong></p>
<p>A: Yes, you will need to re-enter the return details. The system does not save partial return submissions.</p>
<p><strong>Q: Can I process returns through the mobile app instead?</strong></p>
<p>A: Yes, the mobile app maintains a longer session and is recommended for complex returns with multiple items.</p>
<p><strong>Q: How long does the return take to process after submission?</strong></p>
<p>A: Returns are typically processed within 3-5 business days. You will receive an email confirmation when the return is approved.</p>
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": "<h2>Problem</h2><p>When attempting to process a return...</p>",
"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
<!-- [SCREENSHOT: description] --> 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 generationcsm/resolution-notes - Generate structured resolution notes on case closurecsm/suggested-steps - Generate resolution steps that can seed KB contentknowledge/content-recommendation - Recommend existing articles to avoid duplicationknowledge/article-optimization - Optimize article searchability and quality
