참고소스 수정본

참고/instructor-main/docs/blog/posts/structured-output-anthropic.md

@@ -0,0 +1,149 @@
+---
+authors:
+  - jxnl
+categories:
+  - Anthropic
+comments: true
+date: 2024-10-23
+description: Learn how to leverage Anthropic's Claude with Instructor for structured outputs and prompt caching, enhancing AI application development.
+draft: false
+tags:
+  - Anthropic
+  - API Development
+  - Pydantic
+  - Python
+  - LLM Techniques
+  - Prompt Caching
+---
+
+# Structured Outputs and Prompt Caching with Anthropic
+
+Anthropic's ecosystem now offers two powerful features for AI developers: structured outputs and prompt caching. These advancements enable more efficient use of large language models (LLMs). This guide demonstrates how to leverage these features with the Instructor library to enhance your AI applications.
+
+## Structured Outputs with Anthropic and Instructor
+
+Instructor now offers seamless integration with Anthropic's powerful language models, allowing developers to easily create structured outputs using Pydantic models. This integration simplifies the process of extracting specific information from AI-generated responses.
+
+<!-- more -->
+
+To get started, you'll need to install Instructor with Anthropic support:
+
+```bash
+pip install instructor[anthropic]
+```
+
+Here's a basic example of how to use Instructor with Anthropic:
+
+```python
+from pydantic import BaseModel
+from typing import List
+import anthropic
+import instructor
+
+# Patch the Anthropic client with Instructor
+anthropic_client = instructor.from_anthropic(create=anthropic.Anthropic())
+
+
+# Define your Pydantic models
+class Properties(BaseModel):
+    name: str
+    value: str
+
+
+class User(BaseModel):
+    name: str
+    age: int
+    properties: List[Properties]
+
+
+# Use the patched client to generate structured output
+user_response = anthropic_client(
+    model="claude-3-7-sonnet-latest",
+    max_tokens=1024,
+    messages=[
+        {
+            "role": "user",
+            "content": "Create a user for a model with a name, age, and properties.",
+        }
+    ],
+    response_model=User,
+)
+
+print(user_response.model_dump_json(indent=2))
+"""
+{
+  "name": "John Doe",
+  "age": 30,
+  "properties": [
+    { "name": "favorite_color", "value": "blue" }
+  ]
+}
+"""
+```
+
+This approach allows you to easily extract structured data from Claude's responses, making it simpler to integrate AI-generated content into your applications.
+
+## Prompt Caching: Boosting Performance and Reducing Costs
+
+Anthropic has introduced a new prompt caching feature that can significantly improve response times and reduce costs for applications dealing with large context windows. This feature is particularly useful when making multiple calls with similar large contexts over time.
+
+Here's how you can implement prompt caching with Instructor and Anthropic:
+
+```python
+from pydantic import BaseModel
+
+# Set up the client with prompt caching
+client = instructor.from_provider("anthropic/claude-3-5-haiku-latest")
+
+
+# Define your Pydantic model
+class Character(BaseModel):
+    name: str
+    description: str
+
+
+# Load your large context
+with open("./book.txt") as f:
+    book = f.read()
+
+# Make multiple calls using the cached context
+for _ in range(2):
+    resp, completion = client.create_with_completion(
+        model="claude-3-7-sonnet-latest",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "<book>" + book + "</book>",
+                        "cache_control": {"type": "ephemeral"},
+                    },
+                    {
+                        "type": "text",
+                        "text": "Extract a character from the text given above",
+                    },
+                ],
+            },
+        ],
+        response_model=Character,
+        max_tokens=1000,
+    )
+```
+
+In this example, the large context (the book content) is cached after the first request and reused in subsequent requests. This can lead to significant time and cost savings, especially when working with extensive context windows.
+
+## Conclusion
+
+By combining Anthropic's Claude with Instructor's structured output capabilities and leveraging prompt caching, developers can create more efficient, cost-effective, and powerful AI applications. These features open up new possibilities for building sophisticated AI systems that can handle complex tasks with ease.
+
+As the AI landscape continues to evolve, staying up-to-date with the latest tools and techniques is crucial. We encourage you to explore these features and share your experiences with the community. Happy coding!
+
+## Related Documentation
+- [How Patching Works](../../concepts/patching.md) - Understand provider integration
+- [Anthropic Integration](../../integrations/anthropic.md) - Complete setup guide
+
+## See Also
+- [Anthropic Prompt Caching](anthropic-prompt-caching.md) - Optimize Anthropic costs
+- [Unified Provider Interface](announcing-unified-provider-interface.md) - Switch providers easily
+- [Framework Comparison](best_framework.md) - Why Instructor excels