been on a roll recently with first introducing the MCP commonplace, and now launching the brand new Skills feature. Every launch provides one other piece to their rising agentic toolkit, and naturally, the identical questions come up once more: when must you use it, what’s it for, and the way does it match into the present agentic ecosystem?
On this submit, we’ll attempt to reply these questions. After some preliminary exploration, the Expertise function feels to me like a user-wide (and probably organization-wide) file-based type of procedural reminiscence, the place you retailer directions, greatest practices, and utilization patterns for the way the LLM ought to work together with particular instruments or duties.
Particular person expertise are organized folders containing directions, scripts, and assets that Claude can load dynamically to enhance its efficiency on specialised duties. Most examples to date showcase Python code execution, demonstrating how Expertise can automate or prolong workflows instantly inside Claude’s atmosphere. Expertise can exist at completely different ranges of complexity, starting from easy instruction-based workflows to totally featured modular capabilities that mix code, metadata, and assets. At their core, every Ability is a folder that packages directions and elective scripts, permitting Claude to dynamically load the best context for a activity. For instance, a fundamental Ability would possibly solely embody a brief description and markdown-based steerage, whereas a extra superior one might bundle reference recordsdata and executable scripts for repeatable automation throughout instruments or MCP servers. Right here is an instance of a SKILL.md file.
=== Degree 1
---
title: pdf-processing
description: Extract textual content and tables from PDF recordsdata, fill types, and merge paperwork. Use when working with PDF recordsdata or when the consumer mentions PDFs, types, or doc extraction.
---
=== Degree 2
# PDF Processing
## Fast begin
Use pdfplumber to extract textual content from PDFs:
```python
import pdfplumber
with pdfplumber.open("doc.pdf") as pdf:
textual content = pdf.pages[0].extract_text()
```
=== Degree 3
## When to Load Reference Documentation
Load the suitable reference file when:
### references/pdfplumber-api.md
* You want particulars on all out there strategies for extracting textual content, tables, or metadata.
* You need examples of utilizing `extract_text()`, `extract_tables()`, or structure evaluation options.
* You are troubleshooting inconsistent extraction outcomes or bounding field coordinates.Every ability has three ranges or forms of content material that it might include.
Degree 1 offers concise metadata that’s at all times out there to the LLM for discovery, serving to Claude know when a Ability applies. Degree 2 provides procedural directions that load solely when related, giving Claude task-specific know-how with out consuming context unnecessarily and is accessible because the SKILL.md file. Degree 3 introduces supporting assets and executable scripts, enabling deterministic operations and richer automation. They’re further recordsdata which might be talked about within the SKILL.mdfile in order that the LLM is aware of which file to open and when. Collectively, this progressive construction retains context use environment friendly whereas unlocking more and more highly effective, specialised habits as wanted.
Whereas most examples showcase Expertise with Python code execution, they aren’t restricted to Python code execution. They will additionally outline reusable directions and structured processes for working with different out there instruments or MCP servers, making them a versatile approach to train Claude how one can carry out particular work extra successfully.
Bettering Cypher information of LLMs
In the meanwhile I’m affiliated with Neo4j and subsequently we are going to use it for example in our weblog submit. Most LLMs nonetheless use outdated and deprecated syntax and aren’t conversant in the most recent Cypher patterns, which frequently results in frequent errors. On this submit, we’ll construct a Claude Ability that improves an LLM’s capacity to generate Cypher, whether or not you employ MCP Cypher server or Python code execution to present the LLM the power to fetch data from Neo4j.
One good factor is that you should use Claude that can assist you create a Ability. Simply remember the fact that it’s fairly token intensive, and I hit the Professional model limits a few instances.
My immediate instructed the mannequin to make use of internet search to study syntax deprecation since Neo4j 5.0, embody the up to date subquery format, and deal with quantified path patterns. LLMs typically wrestle with this as a result of most Cypher examples out there on-line had been written earlier than Neo4j 5.0. I additionally added a number of utilization patterns, reminiscent of requiring the mannequin to use a filter earlier than sorting to make sure that the property being sorted will not be null (Though it appears newest Claude fashions don’t have this drawback anymore).
After a couple of iterations, I developed the next Claude Ability. The thought was to focus solely on the learn queries, so I deliberately disregarded any write or index syntax adjustments.
The ability is accessible on GitHub.
Degree 1
The Degree 1 metadata defines the identification and function of the Ability in order that Claude can acknowledge when to activate it. It offers a high-level abstract of what the Ability does and why it’s helpful, making it discoverable throughout tasks that cope with Cypher technology or Neo4j question validation. By conserving this data light-weight and at all times loaded, Claude can shortly match prompts involving Cypher or Neo4j to this Ability while not having to parse detailed directions first.
---
title: neo4j-cypher-guide
description: Complete information for writing trendy Neo4j Cypher learn queries.
Important for text2cypher MCP instruments and LLMs producing Cypher queries.
Covers eliminated/deprecated syntax, trendy replacements, CALL subqueries for reads, COLLECT patterns, sorting greatest practices, and Quantified Path Patterns (QPP) for environment friendly graph traversal.
---It’s conceptually much like a instrument description because it tells the mannequin what the Ability does, when to make use of it, and how much duties it’s related for. The principle distinction is that Ability execution merely opens a file containing procedural reminiscence, that are directions for utilization patterns, as a substitute of invoking a instrument. Nonetheless, you can implement such a instrument that handles reminiscence as nicely (for instance, if you happen to needed to retailer such procedural directions in a database as a substitute of a file).
Degree 2
At Degree 2, the ability strikes past a easy functionality declaration and contains procedural information because the concrete strategies for performing a activity appropriately. When Claude detects a consumer request that matches a ability’s set off (outlined in Degree 1), it dynamically reads the corresponding SKILL.md file from disk. The file is loaded solely when wanted, conserving the context light-weight whereas nonetheless offering detailed directions.
A superb SKILL.md file doesn’t simply describe what the ability can do — it exhibits how to do it safely and appropriately. It normally begins with brief procedural checks and rules that function the mannequin’s working guidelines. These outline what to keep away from, what to favor, and what patterns signify trendy greatest apply. For this instance, the ability focuses on producing trendy Neo4j Cypher queries. It begins by itemizing outdated syntax to keep away from and by establishing clear technology guidelines that implement consistency:
This ability helps generate Neo4j Cypher learn queries utilizing trendy syntax patterns and avoiding deprecated options. It focuses on environment friendly question patterns for graph traversal and knowledge retrieval.
## Fast Compatibility Test
When producing Cypher queries, instantly keep away from these REMOVED options:
- ❌ `id()` perform → Use `elementId()`
- ❌ Implicit grouping keys → Use specific WITH clauses
- ❌ Sample expressions for lists → Use sample comprehension or COLLECT subqueries
- ❌ Repeated relationship variables → Use distinctive variable names
- ❌ Computerized record to boolean coercion → Use specific checks
## Core Ideas for Question Technology
1. **Use trendy syntax patterns** - QPP for complicated traversals, CALL subqueries for complicated reads
2. **Optimize throughout traversal** - Filter early inside patterns, not after growth
3. **All the time filter nulls when sorting** - Add IS NOT NULL checks for sorted properties
4. **Specific is best than implicit** - All the time use specific grouping and kind checking
Lastly, the SKILL.md defines when to tug in further reference recordsdata. This tells Claude when to fetch deeper context reminiscent of migration guides, subquery strategies, or path optimization notes, however provided that the duty requires it.
## When to Load Reference Documentation
Load the suitable reference file when:
### references/deprecated-syntax.md
- Migrating queries from older Neo4j variations
- Encountering syntax errors with legacy queries
- Want full record of eliminated/deprecated options
### references/subqueries.md
- Working with CALL subqueries for reads
- Utilizing COLLECT or COUNT subqueries
- Dealing with complicated aggregations
- Implementing sorting with null filtering
### references/qpp.md
- Optimizing variable-length path queries
- Want early filtering throughout traversal
- Working with paths longer than 3-4 hops
- Complicated sample matching necessitiesAfter defining its guidelines, the ability demonstrates how one can apply them by way of brief examples that mannequin appropriate habits. These snippets aren’t arbitrary, however they present the precise procedural information the mannequin makes use of when producing queries.
### For Aggregations
Use COUNT{}, EXISTS{}, and COLLECT{} subqueries:
```cypher
MATCH (p:Particular person)
WHERE rely{(p)-[:KNOWS]->()} > 5
RETURN p.title,
exists{(p)-[:MANAGES]->()} AS isManager
```
### For Complicated Learn Operations
Use CALL subqueries for stylish knowledge retrieval:
```cypher
MATCH (d:Division)
CALL (d) {
MATCH (d)<-[:WORKS_IN]-(p:Particular person)
WHERE p.wage IS NOT NULL // Filter nulls
WITH p ORDER BY p.wage DESC
LIMIT 3
RETURN acquire(p.title) AS topEarners
}
RETURN d.title, topEarners
```
## Widespread Question Transformations
### Counting Patterns
```cypher
// Outdated: RETURN dimension((n)-[]->())
// Fashionable: RETURN rely{(n)-[]->()}
```
### Checking Existence
```cypher
// Outdated: WHERE exists((n)-[:REL]->())
// Fashionable: WHERE EXISTS {MATCH (n)-[:REL]->()}
// Additionally legitimate: WHERE exists{(n)-[:REL]->()}
```In brief, a Degree 2 ability defines a transparent, step-by-step process inside SKILL.md: it units compatibility checks, encodes the strategy with examples, and specifies when to achieve for additional context.
Degree 3
At Degree 3, the LLM has the power to broaden its personal context intelligently. As a substitute of relying solely on the principle SKILL.md, Claude can determine which supporting recordsdata to load primarily based on what the duty requires. For instance, if a consumer immediate entails legacy syntax, it might open references/deprecated-syntax.md; if it’s about aggregations or subqueries, it might herald references/subqueries.md; and for traversal optimizations, it might load references/qpp.md. These recordsdata stay static markdown, however Claude now has the autonomy to assemble precisely the context it wants from them reasonably than relying on a single entry level.
Degree 3 also can embody executable recordsdata. Whereas not current on this ability, Python scripts might stay alongside the markdown references, as an example, a validate_syntax.py or generate_query.py utility. In that case, Claude might each learn procedural steerage and name the executable to carry out concrete operations reminiscent of validation, transformation, or fast computation.
In brief, Degree 3 provides contextual autonomy and elective execution. Claude can determine which reference supplies to load to purpose extra successfully, and, if out there, it might invoke supporting executables to behave on that reasoning.
P.s. I’m planning to put in writing a weblog submit quickly on how one can add a Neo4j ability for Python code execution.
Instance utilization
We are able to take a look at our Cypher ability by attaching an Cypher MCP server. We’ll use a demo database named corporations , which incorporates details about organizations, individuals, and such. You may set it up with the next MCP configuration.
{
"mcpServers": {
"neo4j-database": {
"command": "uvx",
"args": [ "[email protected]", "--transport", "stdio" ],
"env": {
"NEO4J_URI": "neo4j+s://demo.neo4jlabs.com",
"NEO4J_USERNAME": "corporations",
"NEO4J_PASSWORD": "corporations",
"NEO4J_DATABASE": "corporations"
}
}
}
}Let’s give it an instance query!
On this instance, the mannequin first decided that it wanted to retrieve the graph schema. To observe greatest practices, it then loaded the Neo4j information ability earlier than producing the Cypher question. We are able to see that it used the QPP sample, the advisable method for complicated traversals. Nonetheless all these advantages of utilizing expertise come at a price of elevated price and latency.
We are able to take a look at it with out the ability as nicely to see the distinction.
With out the ability, the LLM instantly generated the Cypher and used the outdated syntax for complicated traversals, which may be as much as 1000x slower.
Abstract
Expertise really feel like a pure subsequent step within the broader transfer towards standardization and reusability inside the agentic ecosystem. They’re primarily modular, file-based constructing blocks for procedural reminiscence, a approach to train fashions how one can work extra persistently with clear, reusable steerage that may be shared throughout tasks or groups. Within the Neo4j context, meaning we are able to lastly give LLMs a dependable reference for contemporary Cypher syntax and greatest practices, as a substitute of hoping they recall scattered examples from outdated sources.
On the similar time, Expertise are nonetheless early. They add one other layer of complexity and a little bit of latency, since every step entails fetching, loading, and decoding further recordsdata. In a way, they’re only a variant of instruments, a structured approach to retailer and reuse directions reasonably than to execute code instantly. It is going to be fascinating to see how the boundary evolves between what belongs within the system immediate and what ought to stay inside a Ability.
Both means, this can be a stable transfer in the best course. It pushes the ecosystem towards extra modular, interpretable, and reusable agent habits. As with every thing on this fast-moving area, it’s nonetheless new, so for now we are going to simply should see what pans out.
The Cypher ability is accessible on GitHub.
