What is AI Patch Application?
Morph's AI patch application is a fast apply model that intelligently merges code edits into existing files. Instead of full file rewrites or simple search-and-replace, it uses advanced AI to understand code context and apply precise changes at 4500+ tokens per second.
What It Does
- ✓ Merges edit snippets with existing code
- ✓ Preserves unchanged code sections
- ✓ Processes at 4500+ tokens/second
- ✓ OpenAI-compatible API
- ✓ Handles complex multi-edit operations
- ✓ Works with any programming language
Traditional tools break when code has changed since the patch was created. AI patch application understands context and intent, making smart decisions about where and how to apply changes.
How AI Apply Patch Works
Morph's fast apply model uses a sophisticated pipeline that takes your original code, edit snippets with "// ... existing code ..." markers, and optional instructions to produce perfectly merged results.
1Edit Parsing
Parse edit snippets with '// ... existing code ...' markers to identify precise changes while preserving context.
2Context Analysis
Understand code structure and use optional instructions to disambiguate complex edits and ensure accurate placement.
3Intelligent Merging
Apply multiple edits in sequence while maintaining code integrity and handling edge cases automatically.
4Fast Generation
Generate the final merged code at 4500+ tokens/second using optimized inference infrastructure.
See It in Action
Git Diff to Code Automation
Connect directly to your git workflow. Apply patches from pull requests, commits, or diff files while maintaining version control integrity.
Quick Example
# Apply code edits with Morph Fast Apply Model
curl -X POST https://api.morphllm.com/v1/chat/completions \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "morph-v3-large",
"messages": [{
"role": "user",
"content": "<instruction>Add error handling to the function</instruction>\n<code>function getData() {\n return fetch(url).then(r => r.json());\n}</code>\n<update>// ... existing code ...\n try {\n return fetch(url).then(r => r.json());\n } catch (error) {\n console.error("Failed to fetch data:", error);\n throw error;\n }\n// ... existing code ...</update>"
}]
}'Integration Options
- Git Hooks: Auto-apply patches on commit/push
- PR Automation: Apply patches from pull request diffs
- Branch Sync: Keep feature branches updated automatically
- Conflict Prevention: Detect and resolve conflicts early
Performance Benchmarks
Comprehensive benchmarking demonstrates significant performance advantages over manual patch application and traditional merge tools.
Performance Comparison
| Metric | Morph AI | Manual Process | Git Merge | Improvement |
|---|---|---|---|---|
| Patch Application Speed | 4500+ tokens/s | ~10 lines/min | Instant* | 95% time reduction |
| Conflict Resolution | 99.2% auto | 0% auto | Basic | 99.2% automation |
| Context Preservation | Semantic | Manual | Line-based | Zero context loss |
| Error Rate | 0.8% | 15-25% | 5-10% | 94% error reduction |
*Git merge is instant but requires manual conflict resolution
API Documentation & Usage
Use the standard OpenAI-compatible API to apply patches automatically. Same interface, faster performance.
Basic Usage - JavaScript
import OpenAI from 'openai';
const openai = new OpenAI({
apiKey: process.env.MORPH_API_KEY,
baseURL: 'https://api.morphllm.com/v1'
});
// Apply code edits with instructions
const response = await openai.chat.completions.create({
model: "morph-v3-large",
messages: [
{
role: "user",
content: `<instruction>${instructions}</instruction>
<code>${initialCode}</code>
<update>${editSnippet}</update>`
}
]
});
const mergedCode = response.choices[0].message.content;Streaming for Large Files
// Stream results for real-time feedback
const stream = await openai.chat.completions.create({
model: "morph-v3-large",
messages: [
{
role: "user",
content: `<instruction>${instructions}</instruction>
<code>${initialCode}</code>
<update>${editSnippet}</update>`
}
],
stream: true
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content || '';
process.stdout.write(content);
}Python Example
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("MORPH_API_KEY"),
base_url="https://api.morphllm.com/v1"
)
def apply_edits(initial_code: str, edit_snippet: str, instructions: str):
response = client.chat.completions.create(
model="morph-v3-large",
messages=[
{
"role": "user",
"content": f"<instruction>{instructions}</instruction>\n<code>{initial_code}</code>\n<update>{edit_snippet}</update>"
}
]
)
return response.choices[0].message.content
# Apply edits with instructions
merged_code = apply_edits(initial_code, edit_snippet, instructions)Best Practices
Get the most out of AI patch application with these practical tips.
Edit Formatting
- • Use "// ... existing code ..." for unchanged sections
- • Include minimal context around edits
- • Make multiple edits in one call
- • Provide clear instructions when needed
Performance Tips
- • Use streaming for large files
- • Batch related edits together
- • Cache frequently used patterns
- • Monitor token usage
Integration Best Practices
- • Follow the tool description format
- • Let AI generate instructions field
- • Handle API errors gracefully
- • Validate merged output
Getting Started
Ready to integrate Morph's fast apply model? Replace full file rewrites with intelligent code merging in minutes.
Automate Your Patch Workflow
4500+ tokens/second. 99.2% accuracy. Zero manual conflicts.