been on a roll currently with first introducing the MCP commonplace, and now launching the brand new Abilities function. Every launch provides one other piece to their rising agentic toolkit, and naturally, the identical questions come up once more: when do you have to use it, what’s it for, and the way does it match into the present agentic ecosystem?
On this publish, we’ll attempt to reply these questions. After some preliminary exploration, the Abilities function feels to me like a user-wide (and probably organization-wide) file-based type of procedural reminiscence, the place you retailer directions, finest practices, and utilization patterns for the way the LLM ought to work together with particular instruments or duties.
Particular person abilities are organized folders containing directions, scripts, and assets that Claude can load dynamically to enhance its efficiency on specialised duties. Most examples up to now showcase Python code execution, demonstrating how Abilities can automate or lengthen workflows immediately inside Claude’s setting. Abilities can exist at totally different ranges of complexity, starting from easy instruction-based workflows to completely featured modular capabilities that mix code, metadata, and assets. At their core, every Ability is a folder that packages directions and non-obligatory scripts, permitting Claude to dynamically load the suitable context for a process. For instance, a primary Ability may solely embrace a brief description and markdown-based steering, 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 kinds, and merge paperwork. Use when working with PDF recordsdata or when the person mentions PDFs, kinds, 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 accessible strategies for extracting textual content, tables, or metadata.
* You need examples of utilizing `extract_text()`, `extract_tables()`, or format evaluation options.
* You are troubleshooting inconsistent extraction outcomes or bounding field coordinates.Every talent has three ranges or kinds of content material that it could possibly include.
Degree 1 offers concise metadata that’s all the time accessible 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 out there because the SKILL.md file. Degree 3 introduces supporting assets and executable scripts, enabling deterministic operations and richer automation. They’re further recordsdata which can 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 conduct as wanted.
Whereas most examples showcase Abilities with Python code execution, they aren’t restricted to Python code execution. They’ll additionally outline reusable directions and structured processes for working with different accessible instruments or MCP servers, making them a versatile solution to educate Claude learn how to carry out particular work extra successfully.
Bettering Cypher information of LLMs
For the time being I’m affiliated with Neo4j and subsequently we are going to use it for example in our weblog publish. Most LLMs nonetheless use outdated and deprecated syntax and aren’t conversant in the most recent Cypher patterns, which regularly results in frequent errors. On this publish, we’ll construct a Claude Ability that improves an LLM’s means to generate Cypher, whether or not you utilize MCP Cypher server or Python code execution to present the LLM the flexibility to fetch data from Neo4j.
One good factor is that you need to use Claude that can assist you create a Ability. Simply understand 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 find out about syntax deprecation since Neo4j 5.0, embrace the up to date subquery format, and deal with quantified path patterns. LLMs typically battle with this as a result of most Cypher examples accessible on-line had been written earlier than Neo4j 5.0. I additionally added a number of utilization patterns, akin to requiring the mannequin to use a filter earlier than sorting to make sure that the property being sorted just isn’t null (Though it appears newest Claude fashions don’t have this downside 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 unnoticed any write or index syntax modifications.
The talent is out there on GitHub.
Degree 1
The Degree 1 metadata defines the identification and objective 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 initiatives that cope with Cypher technology or Neo4j question validation. By protecting this data light-weight and all the time loaded, Claude can rapidly 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 fashionable Neo4j Cypher learn queries.
Important for text2cypher MCP instruments and LLMs producing Cypher queries.
Covers eliminated/deprecated syntax, fashionable replacements, CALL subqueries for reads, COLLECT patterns, sorting finest practices, and Quantified Path Patterns (QPP) for environment friendly graph traversal.
---It’s conceptually just like a software 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 software. Nevertheless, you can implement such a software that handles reminiscence as properly (for instance, in case you wished to retailer such procedural directions in a database as a substitute of a file).
Degree 2
At Degree 2, the talent strikes past a easy functionality declaration and contains procedural information because the concrete strategies for performing a process appropriately. When Claude detects a person request that matches a talent’s set off (outlined in Degree 1), it dynamically reads the corresponding SKILL.md file from disk. The file is loaded solely when wanted, protecting the context light-weight whereas nonetheless offering detailed directions.
SKILL.md file doesn’t simply describe what the talent can do — it exhibits how to do it safely and appropriately. It normally begins with quick procedural checks and ideas that function the mannequin’s working guidelines. These outline what to keep away from, what to favor, and what patterns characterize fashionable finest follow. For this instance, the talent focuses on producing fashionable Neo4j Cypher queries. It begins by itemizing outdated syntax to keep away from and by establishing clear technology guidelines that implement consistency:
This talent helps generate Neo4j Cypher learn queries utilizing fashionable 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()` operate → 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
- ❌ Automated listing to boolean coercion → Use specific checks
## Core Rules for Question Era
1. **Use fashionable syntax patterns** - QPP for complicated traversals, CALL subqueries for complicated reads
2. **Optimize throughout traversal** - Filter early inside patterns, not after enlargement
3. **All the time filter nulls when sorting** - Add IS NOT NULL checks for sorted properties
4. **Express is healthier than implicit** - All the time use specific grouping and kind checking
Lastly, the SKILL.md defines when to drag in further reference recordsdata. This tells Claude when to fetch deeper context akin to 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 listing 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
- Advanced sample matching necessitiesAfter defining its guidelines, the talent demonstrates learn how to apply them by quick examples that mannequin appropriate conduct. 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:Individual)
WHERE depend{(p)-[:KNOWS]->()} > 5
RETURN p.title,
exists{(p)-[:MANAGES]->()} AS isManager
```
### For Advanced Learn Operations
Use CALL subqueries for stylish knowledge retrieval:
```cypher
MATCH (d:Division)
CALL (d) {
MATCH (d)<-[:WORKS_IN]-(p:Individual)
WHERE p.wage IS NOT NULL // Filter nulls
WITH p ORDER BY p.wage DESC
LIMIT 3
RETURN gather(p.title) AS topEarners
}
RETURN d.title, topEarners
```
## Frequent Question Transformations
### Counting Patterns
```cypher
// Outdated: RETURN dimension((n)-[]->())
// Trendy: RETURN depend{(n)-[]->()}
```
### Checking Existence
```cypher
// Outdated: WHERE exists((n)-[:REL]->())
// Trendy: WHERE EXISTS {MATCH (n)-[:REL]->()}
// Additionally legitimate: WHERE exists{(n)-[:REL]->()}
```Briefly, a Degree 2 talent defines a transparent, step-by-step process inside SKILL.md: it units compatibility checks, encodes the strategy with examples, and specifies when to succeed in for further context.
Degree 3
At Degree 3, the LLM has the flexibility to develop its personal context intelligently. As an alternative of relying solely on the principle SKILL.md, Claude can resolve which supporting recordsdata to load primarily based on what the duty requires. For instance, if a person immediate includes legacy syntax, it could possibly open references/deprecated-syntax.md; if it’s about aggregations or subqueries, it could possibly herald references/subqueries.md; and for traversal optimizations, it could possibly load references/qpp.md. These recordsdata stay static markdown, however Claude now has the autonomy to assemble precisely the context it wants from them slightly than relying on a single entry level.
Degree 3 may also embrace executable recordsdata. Whereas not current on this talent, Python scripts might dwell alongside the markdown references, for example, a validate_syntax.py or generate_query.py utility. In that case, Claude might each learn procedural steering and name the executable to carry out concrete operations akin to validation, transformation, or fast computation.
Briefly, Degree 3 provides contextual autonomy and non-obligatory execution. Claude can resolve which reference supplies to load to purpose extra successfully, and, if accessible, it could possibly invoke supporting executables to behave on that reasoning.
P.s. I’m planning to write down a weblog publish quickly on learn how to add a Neo4j talent for Python code execution.
Instance utilization
We are able to check our Cypher talent by attaching an Cypher MCP server. We’ll use a demo database named corporations , which incorporates details about organizations, individuals, and such. You’ll be able to 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 finest practices, it then loaded the Neo4j information talent earlier than producing the Cypher question. We are able to see that it used the QPP sample, the really useful method for complicated traversals. Nevertheless all these advantages of utilizing abilities come at a price of elevated value and latency.
We are able to check it with out the talent as properly to see the distinction.
With out the talent, the LLM immediately generated the Cypher and used the outdated syntax for complicated traversals, which could be as much as 1000x slower.
Abstract
Abilities really feel like a pure subsequent step within the broader transfer towards standardization and reusability throughout the agentic ecosystem. They’re basically modular, file-based constructing blocks for procedural reminiscence, a solution to educate fashions learn how to work extra persistently with clear, reusable steering that may be shared throughout initiatives or groups. Within the Neo4j context, meaning we are able to lastly give LLMs a dependable reference for contemporary Cypher syntax and finest practices, as a substitute of hoping they recall scattered examples from outdated sources.
On the identical time, Abilities are nonetheless early. They add one other layer of complexity and a little bit of latency, since every step includes fetching, loading, and deciphering further recordsdata. In a way, they’re only a variant of instruments, a structured solution to retailer and reuse directions slightly than to execute code immediately. It is going to be fascinating to see how the boundary evolves between what belongs within the system immediate and what ought to dwell inside a Ability.
Both method, it is a stable transfer in the suitable course. It pushes the ecosystem towards extra modular, interpretable, and reusable agent conduct. As with all the pieces on this fast-moving house, it’s nonetheless new, so for now we are going to simply need to see what pans out.
The Cypher talent is out there on GitHub.
