菜单
Build AI agents with tools, memory, and multi-step reasoning - ChatGPT, Claude, Gemini integration patterns
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/claude-office-skills/skills --skill ai-agent-builder命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Analyze contracts for risks, check completeness, and provide actionable recommendations. Supports employment contracts, NDAs, service agreements, and more.
MCP server with 39 tools for Word, Excel, PowerPoint, PDF, OCR operations
Search and analyze academic literature. Find papers, understand research methodologies, and synthesize academic findings for research projects.
基于 SOC 职业分类
正在显示 SKILL.md
| name | ai-agent-builder |
| description | Build AI agents with tools, memory, and multi-step reasoning - ChatGPT, Claude, Gemini integration patterns |
| version | 1.0.0 |
| author | claude-office-skills |
| license | MIT |
| category | ai |
| tags | ["ai-agent","chatgpt","openai","langchain","automation"] |
| department | Engineering |
| models | {"recommended":["claude-opus-4","claude-sonnet-4"]} |
| capabilities | ["agent_design","tool_integration","memory_management","multi_step_reasoning","conversation_flow"] |
| languages | ["en","zh"] |
| related_skills | ["deep-research","n8n-workflow","slack-workflows"] |
Design and build AI agents with tools, memory, and multi-step reasoning capabilities. Covers ChatGPT, Claude, Gemini integration patterns based on n8n's 5,000+ AI workflow templates.
This skill covers:
┌─────────────────────────────────────────────────────────────────┐
│ AI AGENT ARCHITECTURE │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Input │────▶│ Agent │────▶│ Output │ │
│ │ (Query) │ │ (LLM) │ │ (Response) │ │
│ └─────────────┘ └──────┬──────┘ └─────────────┘ │
│ │ │
│ ┌───────────────────┼───────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Tools │ │ Memory │ │ Knowledge │ │
│ │ (Functions) │ │ (Context) │ │ (RAG) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
agent_types:
reactive_agent:
description: "Single-turn response, no memory"
use_case: simple_qa, classification
complexity: low
conversational_agent:
description: "Multi-turn with conversation memory"
use_case: chatbots, support
complexity: medium
tool_using_agent:
description:
tool_definition:
name: "get_weather"
description: "Get current weather for a location"
parameters:
type: object
properties:
location:
type: string
description: "City name or coordinates"
units:
type: string
enum: ["celsius", "fahrenheit"]
default: "celsius"
required: ["location"]
implementation:
type: api_call
endpoint: "https://api.weather.com/v1/current"
method: GET
params:
q: "{location}"
units: "{units}"
tool_categories:
data_retrieval:
- web_search: search the internet
- database_query: query SQL/NoSQL
- api_lookup: call external APIs
- file_read: read documents
actions:
- send_email: send emails
- create_calendar: schedule events
- update_crm: modify CRM records
- post_slack: send Slack messages
computation:
- calculator: math operations
- code_interpreter: run Python
- data_analysis: analyze datasets
generation:
- image_generation: create images
- document_creation: generate docs
- chart_creation: create visualizations
n8n_agent_workflow:
nodes:
- trigger:
type: webhook
path: "/ai-agent"
- ai_agent:
type: "@n8n/n8n-nodes-langchain.agent"
model: openai_gpt4
system_prompt: |
You are a helpful assistant that can:
1. Search the web for information
2. Query our customer database
3. Send emails on behalf of the user
tools:
- web_search
- database_query
- send_email
- respond:
type: respond_to_webhook
data: "{{ $json.output }}"
memory_types:
buffer_memory:
description: "Store last N messages"
implementation: |
messages = []
def add_message(role, content):
messages.append({"role": role, "content": content})
if len(messages) > MAX_MESSAGES:
messages.pop(0)
use_case: simple_chatbots
summary_memory:
description: "Summarize conversation periodically"
implementation: |
When messages > threshold:
summary = llm.summarize(messages[:-5])
messages = [summary_message] + messages[-5:]
use_case: long_conversations
vector_memory:
description: "Store in vector DB for semantic retrieval"
implementation: |
# Store
embedding = embed(message)
vector_db.insert(embedding, message)
# Retrieve
relevant = vector_db.search(query_embedding, k=5)
use_case: knowledge_retrieval
entity_memory:
description: "Track entities mentioned in conversation"
implementation: |
entities = {}
def update_entities(message):
extracted = llm.extract_entities(message)
entities.update(extracted)
use_case: personalized_assistants
context_management:
strategies:
sliding_window:
keep: last_n_messages
n: 10
relevance_based:
method: embed_and_rank
keep: top_k_relevant
k: 5
hierarchical:
levels:
- immediate: last_3_messages
- recent: summary_of_last_10
- long_term: key_facts_from_all
token_budget:
total: 8000
system_prompt: 1000
tools: 1000
memory: 4000
current_query: 1000
response: 1000
Thought: I need to find information about X
Action: web_search("X")
Observation: [search results]
Thought: Based on the results, I should also check Y
Action: database_query("SELECT * FROM Y")
Observation: [database results]
Thought: Now I have enough information to answer
Action: respond("Final answer based on X and Y")
planning_workflow:
step_1_plan:
prompt: |
Task: {user_request}
Create a step-by-step plan to complete this task.
Each step should be specific and actionable.
output: numbered_steps
step_2_execute:
for_each: step
actions:
- execute_step
- validate_result
- adjust_if_needed
step_3_synthesize:
prompt: |
Steps completed: {executed_steps}
Results: {results}
Synthesize a final response for the user.
slack_agent:
trigger: slack_message
workflow:
1. receive_message:
extract: [user, channel, text, thread_ts]
2. get_context:
if: thread_ts
action: fetch_thread_history
3. process_with_agent:
model: gpt-4
system: "You are a helpful Slack assistant"
tools: [web_search, jira_lookup, calendar_check]
4. respond:
action: post_to_slack
channel: "{channel}"
thread_ts: "{thread_ts}"
text: "{agent_response}"
telegram_agent:
trigger: telegram_message
handlers:
text_message:
- extract_text
- process_with_ai
- send_response
voice_message:
- transcribe_with_whisper
- process_with_ai
- send_text_or_voice_response
image:
- analyze_with_vision
- process_with_ai
- send_response
document:
- extract_content
- process_with_ai
- send_response
web_chat_agent:
frontend:
type: react_component
features:
- message_input
- message_history
- typing_indicator
- file_upload
backend:
endpoint: "/api/chat"
method: POST
streaming: true
session_management:
method: jwt_token
storage: redis
ttl: 24_hours
support_agent:
name: "Customer Support AI"
model: gpt-4
system_prompt: |
You are a customer support agent for {company}.
Guidelines:
- Be helpful, professional, and empathetic
- Use the knowledge base to answer questions
- Escalate to human if you cannot help
- Never make up information
Available actions:
- Search knowledge base
- Look up customer account
- Create support ticket
- Escalate to human agent
tools:
- knowledge_search:
description: "Search help articles"
- customer_lookup:
description: "Get customer account info"
- create_ticket:
description: "Create support ticket"
- escalate:
description: "Transfer to human agent"
escalation_triggers:
- sentiment: very_negative
- keywords: ["speak to human", "manager", "complaint"]
- failed_resolution: after_3_attempts
research_agent:
name: "Research Assistant"
model: claude-opus
system_prompt: |
You are a research assistant that helps users find
and synthesize information on any topic.
Process:
1. Understand the research question
2. Plan search strategy
3. Execute searches across multiple sources
4. Synthesize findings
5. Present with citations
tools:
- web_search
- academic_search
- news_search
- wikipedia_lookup
output_format:
- executive_summary
- key_findings
- detailed_analysis
- sources_cited
Request: "Design an AI agent for appointment scheduling"
Output:
# Appointment Scheduling Agent Design
## Architecture
```yaml
agent:
name: "Scheduling Assistant"
model: gpt-4
capabilities:
- Check calendar availability
- Book appointments
- Send confirmations
- Handle rescheduling
- Answer FAQs
calendar_check
book_appointment
send_notification
customer_lookup
User: "I'd like to book an appointment"
Agent: [Thought: Need to know service type and preferred time]
Agent: "I'd be happy to help! What service are you looking for,
and do you have a preferred date/time?"
User: "Haircut, next Tuesday afternoon"
Agent: [Action: calendar_check(date="next Tuesday", time="afternoon")]
Agent: "I have availability at 2pm, 3pm, and 4:30pm next Tuesday.
Which works best for you?"
User: "3pm please"
Agent: [Action: book_appointment(datetime="Tuesday 3pm", service="haircut")]
Agent: [Action: send_notification(type="confirmation", ...)]
Agent: "You're all set for a haircut at 3pm next Tuesday.
I've sent a confirmation to your email. See you then!"
workflow:
- webhook_trigger: /schedule-chat
- ai_agent:
tools: [calendar, booking, notification]
- respond_to_user
---
*AI Agent Builder Skill - Part of Claude Office Skills*