# AI Agent Protocol & Instructions Path: `AGENTS.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/AGENTS.md) --- name: blog-post description: Writes and structures long-form blog posts, creates tutorial outlines, and optimizes content for SEO with cover image generation. Use when the user asks to write a blog post, article, how-to guide, tutorial, technical writeup, thought leadership piece, or long-form content. --- # Blog Post Writing Skill ## Research First (Required) **Before writing any blog post, you MUST delegate research:** 1. Use the `task` tool with `subagent_type: "researcher"` 2. In the description, specify BOTH the topic AND where to save: ``` task( subagent_type="researcher", description="Research [TOPIC]. Save findings to research/[slug].md" ) ``` Example: ``` task( subagent_type="researcher", description="Research the current state of AI agents in 2025. Save findings to research/ai-agents-2025.md" ) ``` 3. After research completes, read the findings file before writing ## Output Structure (Required) **Every blog post MUST have both a post AND a cover image:** ``` blogs/ └── / ├── post.md # The blog post content └── hero.png # REQUIRED: Generated cover image ``` Example: A post about "AI Agents in 2025" → `blogs/ai-agents-2025/` **You MUST complete both steps:** 1. Write the post to `blogs//post.md` 2. Generate a cover image using `generate_image` and save to `blogs//hero.png` **A blog post is NOT complete without its cover image.** ## Blog Post Structure Every blog post should follow this structure: ### 1. Hook (Opening) - Start with a compelling question, statistic, or statement - Make the reader want to continue - Keep it to 2-3 sentences ### 2. Context (The Problem) - Explain why this topic matters - Describe the problem or opportunity - Connect to the reader's experience ### 3. Main Content (The Solution) - Break into 3-5 main sections with H2 headers - Each section covers one key point - Include code examples, diagrams, or screenshots where helpful - Use bullet points for lists ### 4. Practical Application - Show how to apply the concepts - Include step-by-step instructions if applicable - Provide code snippets or templates ### 5. Conclusion & CTA - Summarize key takeaways (3 bullets max) - End with a clear call-to-action - Link to related resources ## Cover Image Generation After writing the post, generate a cover image using the `generate_cover` tool: ``` generate_cover(prompt="A detailed description of the image...", slug="your-blog-slug") ``` The tool saves the image to `blogs//hero.png`. ### Writing Effective Image Prompts Structure your prompt with these elements: 1. **Subject**: What is the main focus? Be specific and concrete. 2. **Style**: Art direction (minimalist, isometric, flat design, 3D render, watercolor, etc.) 3. **Composition**: How elements are arranged (centered, rule of thirds, symmetrical) 4. **Color palette**: Specific colors or mood (warm earth tones, cool blues and purples, high contrast) 5. **Lighting/Atmosphere**: Soft diffused light, dramatic shadows, golden hour, neon glow 6. **Technical details**: Aspect ratio considerations, negative space for text overlay ### Example Prompts **For a technical blog post:** ``` Isometric 3D illustration of interconnected glowing cubes representing AI agents, each cube has subtle circuit patterns. Cubes connected by luminous data streams. Deep navy background (#0a192f) with electric blue (#64ffda) and soft purple (#c792ea) accents. Clean minimal style, lots of negative space at top for title. Professional tech aesthetic. ``` **For a tutorial/how-to:** ``` Clean flat illustration of hands typing on a keyboard with abstract code symbols floating upward, transforming into lightbulbs and gears. Warm gradient background from soft coral to light peach. Friendly, approachable style. Centered composition with space for text overlay. ``` **For thought leadership:** ``` Abstract visualization of a human silhouette profile merging with geometric neural network patterns. Split composition - organic watercolor texture on left transitioning to clean vector lines on right. Muted sage green and warm terracotta color scheme. Contemplative, forward-thinking mood. ``` ## SEO Considerations - Include the main keyword in the title and first paragraph - Use the keyword naturally 3-5 times throughout - Keep the title under 60 characters - Write a meta description (150-160 characters) ## Quality Checklist Before finishing: - [ ] Post saved to `blogs//post.md` - [ ] Hero image generated at `blogs//hero.png` - [ ] Hook grabs attention in first 2 sentences - [ ] Each section has a clear purpose - [ ] Conclusion summarizes key points - [ ] CTA tells reader what to do next --- name: social-media description: Drafts engaging social media posts, writes hooks, suggests hashtags, creates thread structures, and generates companion images. Use when the user asks to write a LinkedIn post, tweet, Twitter/X thread, social media caption, social post, or repurpose content for social platforms. --- # Social Media Content Skill ## Research First (Required) **Before writing any social media content, you MUST delegate research:** 1. Use the `task` tool with `subagent_type: "researcher"` 2. In the description, specify BOTH the topic AND where to save: ``` task( subagent_type="researcher", description="Research [TOPIC]. Save findings to research/[slug].md" ) ``` Example: ``` task( subagent_type="researcher", description="Research renewable energy trends in 2025. Save findings to research/renewable-energy.md" ) ``` 3. After research completes, read the findings file before writing ## Output Structure (Required) **Every social media post MUST have both content AND an image:** **LinkedIn posts:** ``` linkedin/ └── / ├── post.md # The post content └── image.png # REQUIRED: Generated visual ``` **Twitter/X threads:** ``` tweets/ └── / ├── thread.md # The thread content └── image.png # REQUIRED: Generated visual ``` Example: A LinkedIn post about "prompt engineering" → `linkedin/prompt-engineering/` **You MUST complete both steps:** 1. Write the content to the appropriate path 2. Generate an image using `generate_image` and save alongside the post **A social media post is NOT complete without its image.** ## Platform Guidelines ### LinkedIn **Format:** - 1,300 character limit (show more after ~210 chars) - First line is crucial - make it hook - Use line breaks for readability - 3-5 hashtags at the end **Tone:** - Professional but personal - Share insights and learnings - Ask questions to drive engagement - Use "I" and share experiences **Structure:** ``` [Hook - 1 compelling line] [Empty line] [Context - why this matters] [Empty line] [Main insight - 2-3 short paragraphs] [Empty line] [Call to action or question] #hashtag1 #hashtag2 #hashtag3 ``` ### Twitter/X **Format:** - 280 character limit per tweet - Threads for longer content (use 1/🧵 format) - No more than 2 hashtags per tweet **Thread Structure:** ``` 1/🧵 [Hook - the main insight] 2/ [Supporting point 1] 3/ [Supporting point 2] 4/ [Example or evidence] 5/ [Conclusion + CTA] ``` ## Image Generation Every social media post needs an eye-catching image. Use the `generate_social_image` tool: ``` generate_social_image(prompt="A detailed description...", platform="linkedin", slug="your-post-slug") ``` The tool saves the image to `//image.png`. ### Social Image Best Practices Social images need to work at small sizes in crowded feeds: - **Bold, simple compositions** - one clear focal point - **High contrast** - stands out when scrolling - **No text in image** - too small to read, platforms add their own - **Square or 4:5 ratio** - works across platforms ### Writing Effective Prompts Include these elements: 1. **Single focal point**: One clear subject, not a busy scene 2. **Bold style**: Vibrant colors, strong shapes, high contrast 3. **Simple background**: Solid color, gradient, or subtle texture 4. **Mood/energy**: Match the post tone (inspiring, urgent, thoughtful) ### Example Prompts **For an insight/tip post:** ``` Single glowing lightbulb floating against a deep purple gradient background, lightbulb made of interconnected golden geometric lines, rays of soft light emanating outward. Minimal, striking, high contrast. Square composition. ``` **For announcements/news:** ``` Abstract rocket ship made of colorful geometric shapes launching upward with a trail of particles. Bright coral and teal color scheme against clean white background. Energetic, celebratory mood. Bold flat illustration style. ``` **For thought-provoking content:** ``` Two overlapping translucent circles, one blue one orange, creating a glowing intersection in the center. Represents collaboration or intersection of ideas. Dark charcoal background, soft ethereal glow. Minimalist and contemplative. ``` ## Content Types ### Announcement Posts - Lead with the news - Explain the impact - Include link or next step ### Insight Posts - Share one specific learning - Explain the context briefly - Make it actionable ### Question Posts - Ask a genuine question - Provide your take first - Keep it focused on one topic ## Quality Checklist Before finishing: - [ ] Post saved to `linkedin//post.md` or `tweets//thread.md` - [ ] Image generated alongside the post - [ ] First line hooks attention - [ ] Content fits platform limits - [ ] Tone matches platform norms - [ ] Has clear CTA or question - [ ] Hashtags are relevant (not generic) --- name: code-review description: Perform a structured code review of changes, checking for correctness, style, tests, and potential issues. --- # Code Review Skill Use this skill after implementing changes to validate your work before delivering. ## Review Checklist ### 1. Correctness - [ ] Changes solve the original issue/task - [ ] No unintended side effects on existing functionality - [ ] Edge cases are handled - [ ] Error handling is appropriate (not excessive) ### 2. Code Quality - [ ] Code matches existing style and patterns - [ ] No unnecessary complexity or abstraction - [ ] Variable and function names are clear - [ ] No dead code, commented-out code, or TODOs left behind ### 3. Tests - [ ] New functionality has test coverage - [ ] Existing tests still pass - [ ] Tests cover both happy path and error cases - [ ] Tests are not brittle (don't test implementation details) ### 4. Safety - [ ] No hardcoded secrets or credentials - [ ] User input is validated at boundaries - [ ] No SQL injection, XSS, or command injection vectors - [ ] File operations use safe paths ## Process 1. Read each modified file end-to-end (not just the diff) 2. Run the test suite: `execute("python -m pytest -v")` 3. Run linters if available: `execute("ruff check .")` 4. Run the bundled lint check: `execute("python /skills/code-review/lint_check.py .")` 5. Check against each item in the review checklist 6. If any issues found, fix them and re-review 7. When everything passes, the review is complete ## Helper Scripts - **`/skills/code-review/lint_check.py`** — Scans Python files for missing docstrings, long functions (>50 lines), and bare `except:` clauses. Run it via `execute("python /skills/code-review/lint_check.py [path ...]")`. --- name: coding-prefs description: Read the user's coding preferences from /memory/coding-prefs.md before making non-trivial style decisions, and append new preferences when the user gives durable feedback. --- # Coding Preferences Skill Use this skill to keep `/memory/coding-prefs.md` in sync with how this specific user wants you to work. This file is **user-scoped**, so each user has their own copy — anything you write here only affects future conversations with the same user. ## When to Read - Before picking a code style, test framework, or commit message format - Before deciding whether to add comments, type hints, or docstrings - Before refactoring beyond what was asked ## When to Write Append a new entry whenever the user gives feedback that should apply to future work: - "Don't add docstrings unless I ask" → save it - "I prefer pytest over unittest" → save it - "Stop summarizing what you did at the end" → save it Each entry should be one line: the rule, then a brief reason if the user gave one. ## How to Write Read the file first (it may not exist yet), then append. Don't overwrite — preferences accumulate over time. If a new preference contradicts an existing one, replace the old line and note the change. --- name: planning description: Break down a coding task into a structured implementation plan with clear steps, file identification, and risk assessment. --- # Planning Skill Use this skill when starting a new coding task to create a thorough implementation plan. ## Steps ### 1. Understand the Task - Read the issue/task description completely - Identify the expected outcome and acceptance criteria - Note any constraints or requirements mentioned ### 2. Explore the Codebase - Find the repository root and read the project structure - Identify the tech stack (language, framework, test runner) - Read README, CONTRIBUTING, or similar docs if they exist - Find existing tests to understand testing patterns ### 3. Identify Relevant Files - Use `grep` to find code related to the task - Read the most relevant files (entry points, related modules) - Identify which files need to be modified vs. created - Check for existing patterns you should follow ### 4. Write the Plan Use `write_todos` to create a structured plan: ``` write_todos([ "1. ", "2. ", "3. Write tests for ", "4. Run test suite and fix failures", "5. Review all changes" ]) ``` ### 5. Assess Risks - Are there breaking changes? - Are there edge cases to handle? - Does this affect other parts of the codebase? - Flag anything uncertain for review ## Guidelines - Plans should have 3-10 concrete steps - Each step should be specific enough to execute without further planning - Include test writing and test running as explicit steps - End with a review/verification step --- name: blog-post description: Write structured long-form blog posts with research, SEO optimization, and cover image generation. --- # Blog Post Writing Skill ## Research First (Required) Before writing any blog post, delegate research: 1. Use the `task` tool with `subagent_type: "researcher"` 2. Specify both the topic AND where to save findings ## Blog Post Structure Every blog post should follow this structure: ### 1. Hook (Opening) - Start with a compelling question, statistic, or statement - Keep it to 2-3 sentences ### 2. Context (The Problem) - Explain why this topic matters - Connect to the reader's experience ### 3. Main Content (3-5 sections) - Each section covers one key point with an H2 header - Include code examples where helpful - Use bullet points for lists of 3+ items ### 4. Practical Application - Show how to apply the concepts - Include step-by-step instructions or code snippets ### 5. Conclusion & CTA - Summarize key takeaways (3 bullets max) - End with a clear call-to-action ## Output Save the blog post to `blogs//post.md`. ## SEO Considerations - Include the main keyword in the title and first paragraph - Keep the title under 60 characters - Write a meta description (150-160 characters) --- name: social-media description: Create social media content including Twitter/X threads, LinkedIn posts, and short-form updates. --- # Social Media Content Skill ## Formats ### Twitter/X Thread - Hook tweet: compelling question or bold statement (< 280 chars) - 3-7 follow-up tweets expanding on the topic - Final tweet with CTA or key takeaway - Use line breaks for readability ### LinkedIn Post - Opening hook (first 2 lines visible before "see more") - 3-5 short paragraphs with key insights - End with a question to drive engagement - 1,300 character target length ### Short-form Update - Single paragraph announcement or insight - Link to longer content if available - Under 280 characters for cross-platform use ## Guidelines - Write in first person for LinkedIn, third person for company accounts - Include 2-3 relevant hashtags (not more) - Adapt tone: LinkedIn is more professional, Twitter is more conversational - Every post should provide standalone value — don't just tease - Use concrete numbers and results over vague claims ## Output Save content to `social//.md` (e.g., `social/twitter/ai-agents-thread.md`). --- name: competitor-analysis description: >- Analyze competitors in a given market segment. Trigger on: competitive landscape, competitor analysis, market comparison, competitive positioning. --- # Competitor Analysis When asked to analyze competitors: 1. Identify the top 3-5 competitors in the target segment 2. For each competitor, assess: - Product positioning and key differentiators - Pricing model and tiers - Target audience and market share estimates - Strengths and weaknesses 3. Create a comparison matrix 4. Identify gaps and opportunities for differentiation # analyze-market Path: `examples/deploy-gtm-agent/subagents/market-researcher/skills/analyze-market/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/examples/deploy-gtm-agent/subagents/market-researcher/skills/analyze-market/SKILL.md) --- name: cudf-analytics description: Use for GPU-accelerated data analysis on datasets, CSVs, or tabular data using NVIDIA cuDF. Triggers when tasks involve groupby aggregations, statistical summaries, anomaly detection, or large-scale data profiling. --- # cuDF Analytics Skill GPU-accelerated data analysis using NVIDIA RAPIDS cuDF. cuDF provides a pandas-like API that runs on NVIDIA GPUs, enabling massive speedups on large datasets. ## When to Use This Skill Use this skill when: - Analyzing CSV files, datasets, or tabular data - Computing statistical summaries (mean, median, std, quartiles) - Performing groupby aggregations - Detecting anomalies or outliers in data - Profiling datasets with millions of rows - Computing correlation matrices ## Initialization (REQUIRED) Always start every script with this boilerplate. It tests actual GPU operations, not just import. ```python import pandas as pd try: import cudf # Smoke-test: verify GPU compute AND host transfer both work _test = cudf.Series([1, 2, 3]) assert _test.sum() == 6 assert _test.to_pandas().tolist() == [1, 2, 3] GPU = True except Exception as e: print(f"[GPU] cudf unavailable, falling back to pandas: {e}") GPU = False def read_csv(path): return cudf.read_csv(path) if GPU else pd.read_csv(path) def to_pd(df): """Convert cuDF DataFrame/Series to pandas. Use this instead of .to_pandas() directly.""" if not GPU: return df try: return df.to_pandas() except Exception as e: print(f"[GPU] .to_pandas() failed, using Arrow fallback: {e}") return df.to_arrow().to_pandas() ``` ## Quick Reference cuDF mirrors the pandas API. Common operations: ### Read Data ```python df = read_csv("data.csv") ``` ### Statistical Summary ```python # Use to_pd() when you need pandas output summary = to_pd(df[["value", "score"]].describe()) # Scalar values work directly with float() mean_val = float(df["value"].mean()) q1 = float(df["value"].quantile(0.25)) # Correlation corr = float(df["value"].corr(df["score"])) ``` ### Groupby Aggregation ```python result = df.groupby("category").agg({ "revenue": ["sum", "mean", "count"], "quantity": ["sum", "mean"], }) result_pd = to_pd(result) ``` ### Anomaly Detection (IQR Method) ```python col = "value" Q1 = float(df[col].quantile(0.25)) Q3 = float(df[col].quantile(0.75)) IQR = Q3 - Q1 lower = Q1 - 1.5 * IQR upper = Q3 + 1.5 * IQR outliers = to_pd(df[(df[col] < lower) | (df[col] > upper)]) ``` ### Anomaly Detection (Z-Score Method) ```python mean = float(df[col].mean()) std = float(df[col].std()) df["z_score"] = (df[col] - mean) / std anomalies = to_pd(df[df["z_score"].abs() > 3]) ``` ### Filtering and Selection ```python # Filter rows filtered = df[df["status"] == "active"] # Select columns subset = df[["name", "revenue", "date"]] # Sort sorted_df = df.sort_values("revenue", ascending=False) # Convert to pandas for final output / iteration result_pd = to_pd(sorted_df) ``` ## Data Type Requirements cuDF requires explicit type specification for optimal performance: - Use `float32` or `float64` for numeric data - Use `int32` or `int64` for integer data - String columns use cuDF's string dtype automatically ## Output Guidelines When reporting analysis results: - Include dataset dimensions (rows x columns) - Show key statistics in formatted tables - Highlight notable patterns, trends, or anomalies - Provide both summary statistics and specific examples - Note any data quality issues (missing values, outliers) --- name: cuml-machine-learning description: Use for GPU-accelerated machine learning on tabular data using NVIDIA cuML. Triggers when tasks involve classification, regression, clustering, dimensionality reduction, or model training on datasets. --- # cuML Machine Learning Skill GPU-accelerated machine learning using NVIDIA RAPIDS cuML. cuML provides a scikit-learn-compatible API that runs on NVIDIA GPUs, enabling massive speedups on large datasets. ## When to Use This Skill Use this skill when: - Training classification models (predict categories, detect fraud, classify text) - Training regression models (forecast values, predict prices, estimate quantities) - Clustering data (segment customers, group documents, find patterns) - Dimensionality reduction (visualize high-dimensional data, compress features) - Preprocessing and feature engineering on large datasets - Any ML task on datasets with 10K+ rows where GPU acceleration helps ## Initialization (REQUIRED) Always start every script with this boilerplate. It tests actual GPU ML operations. ```python import pandas as pd import numpy as np try: import cudf import cuml # Smoke-test: verify GPU ML works end-to-end _test_data = cudf.DataFrame({'a': [1.0, 2.0, 3.0, 4.0], 'b': [5.0, 6.0, 7.0, 8.0]}) _km = cuml.cluster.KMeans(n_clusters=2, n_init=1, random_state=42) _km.fit(_test_data) assert len(_km.labels_) == 4 GPU = True except Exception as e: print(f"[GPU] cuml unavailable, falling back to scikit-learn: {e}") GPU = False def read_csv(path): return cudf.read_csv(path) if GPU else pd.read_csv(path) def to_pd(df): """Convert cuML/cuDF output to pandas. Use this instead of .to_pandas() directly.""" if not GPU: return df try: return df.to_pandas() except Exception as e: print(f"[GPU] .to_pandas() failed, using Arrow fallback: {e}") return df.to_arrow().to_pandas() ``` ## Import Patterns ```python # GPU mode if GPU: from cuml.cluster import KMeans, DBSCAN, HDBSCAN from cuml.ensemble import RandomForestClassifier, RandomForestRegressor from cuml.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression from cuml.neighbors import KNeighborsClassifier, KNeighborsRegressor from cuml.svm import SVC, SVR from cuml.decomposition import PCA, TruncatedSVD from cuml.manifold import UMAP, TSNE from cuml.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder from cuml.model_selection import train_test_split from cuml.metrics import accuracy_score, r2_score, mean_squared_error # CPU fallback else: from sklearn.cluster import KMeans, DBSCAN, HDBSCAN from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor from sklearn.svm import SVC, SVR from sklearn.decomposition import PCA, TruncatedSVD from sklearn.manifold import TSNE from sklearn.preprocessing import StandardScaler, MinMaxScaler, LabelEncoder from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, r2_score, mean_squared_error # UMAP not in sklearn — skip or pip install umap-learn ``` ## Quick Reference ### Train/Test Split (Start Here) ```python X = df[["feature1", "feature2", "feature3"]].astype("float32") y = df["target"] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) ``` ### Classification ```python model = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42) model.fit(X_train, y_train) predictions = model.predict(X_test) accuracy = float(accuracy_score(to_pd(y_test), to_pd(predictions))) print(f"Accuracy: {accuracy:.4f}") # Feature importances (tree models only) importances = to_pd(model.feature_importances_) for name, imp in zip(feature_names, importances): print(f" {name}: {imp:.4f}") ``` ### Regression ```python model = Ridge(alpha=1.0) model.fit(X_train, y_train) predictions = model.predict(X_test) r2 = float(r2_score(to_pd(y_test), to_pd(predictions))) mse = float(mean_squared_error(to_pd(y_test), to_pd(predictions))) print(f"R² Score: {r2:.4f}") print(f"MSE: {mse:.4f}") # Coefficients coeffs = to_pd(model.coef_) print(f"Intercept: {float(model.intercept_):.4f}") ``` ### Clustering (KMeans) ```python X = df[["feature1", "feature2"]].astype("float32") model = KMeans(n_clusters=4, n_init=10, random_state=42) model.fit(X) labels = to_pd(model.labels_) centroids = to_pd(model.cluster_centers_) inertia = float(model.inertia_) print(f"Inertia: {inertia:.2f}") print(f"Cluster sizes: {labels.value_counts().sort_index().to_dict()}") print(f"Centroids:\n{centroids}") ``` ### Dimensionality Reduction (PCA) ```python scaler = StandardScaler() X_scaled = scaler.fit_transform(X.astype("float32")) pca = PCA(n_components=3) X_reduced = pca.fit_transform(X_scaled) variance_ratio = to_pd(pca.explained_variance_ratio_) print(f"Explained variance: {[f'{v:.4f}' for v in variance_ratio]}") print(f"Total explained: {float(sum(variance_ratio)):.4f}") ``` ### Dimensionality Reduction (UMAP — GPU only) ```python if GPU: reducer = UMAP(n_components=2, n_neighbors=15, min_dist=0.1, random_state=42) embedding = to_pd(reducer.fit_transform(X_scaled)) print(f"UMAP embedding shape: {embedding.shape}") ``` ### Preprocessing ```python # Scale numeric features scaler = StandardScaler() X_scaled = scaler.fit_transform(X.astype("float32")) # Encode categorical columns le = LabelEncoder() df["category_encoded"] = le.fit_transform(df["category"]) ``` ## Data Type Requirements - cuML requires **float32 or float64** for features. Always cast: `X.astype("float32")` - Integer targets (classification labels) work directly - Categorical columns must be encoded first (LabelEncoder or OneHotEncoder) - cuML does NOT support sparse matrices — always use dense data ## Gotchas | Issue | Fix | |-------|-----| | `TypeError: sparse input` | Convert to dense: `X.toarray()` or don't use sparse | | PCA `solver='randomized'` fails | Use `solver='full'` or omit (cuML auto-selects) | | UMAP not available on CPU | Skip UMAP in CPU mode or `pip install umap-learn` | | Float64 slower than float32 | Cast to float32: `X.astype("float32")` | | Large dataset OOM | Reduce features or sample data before fitting | ## Output Guidelines When reporting ML results: - Include dataset shape (rows × features) and target distribution - Show train/test split sizes - Report key metrics in a formatted table (accuracy, R², MSE, etc.) - For classification: show per-class metrics if multi-class - For clustering: show cluster sizes and centroid summaries - For dimensionality reduction: show explained variance ratios - List feature importances ranked by magnitude - Note any data quality issues (class imbalance, missing values, outliers) --- name: data-visualization description: Use for creating publication-quality charts and multi-panel analysis summaries. Triggers when tasks involve visualizing data, plotting results, creating charts, or producing visual reports from analysis output. --- # Data Visualization Skill Create publication-quality analytical charts using matplotlib and seaborn in a headless GPU sandbox. Charts are saved as PNG files to `/workspace/` for retrieval. ## When to Use This Skill Use this skill when: - Visualizing results from cuDF analysis or cuML models - Creating charts (bar, line, scatter, heatmap, histogram, box plot) - Building multi-panel analysis summaries - The user asks for visual output, plots, graphs, or charts - Presenting statistical findings with figures ## Initialization (REQUIRED) MUST call `matplotlib.use('Agg')` BEFORE importing pyplot. This enables headless rendering. ```python import matplotlib matplotlib.use('Agg') # Headless backend — MUST be before pyplot import import matplotlib.pyplot as plt import numpy as np # Publication-quality defaults plt.rcParams.update({ 'figure.dpi': 100, 'savefig.dpi': 300, 'font.size': 11, 'axes.labelsize': 12, 'axes.titlesize': 14, 'xtick.labelsize': 10, 'ytick.labelsize': 10, 'legend.fontsize': 10, 'figure.constrained_layout.use': True, }) # Colorblind-safe palette (Okabe-Ito) COLORS = ['#0173B2', '#DE8F05', '#029E73', '#D55E00', '#CC78BC', '#CA9161', '#FBAFE4', '#949494', '#ECE133', '#56B4E9'] ``` ## Saving Charts Always save to `/workspace/` with these settings: ```python plt.savefig('/workspace/chart_name.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` - `dpi=300` for print quality - `bbox_inches='tight'` removes excess whitespace - `facecolor='white'` ensures white background - Always call `plt.close()` after saving to free memory ## Displaying Charts (REQUIRED) After saving any chart, you MUST call `read_file` on it to display it inline in the conversation: ``` read_file("/workspace/chart_name.png") ``` Users cannot see charts unless you do this. Every chart you save MUST be followed by a `read_file` call. ## Quick Reference ### Bar Chart (from groupby results) ```python # After: result = to_pd(df.groupby("category")["value"].mean()) fig, ax = plt.subplots(figsize=(8, 5)) bars = ax.bar(result.index, result.values, color=COLORS[:len(result)], edgecolor='black', linewidth=0.8) for bar in bars: height = bar.get_height() ax.text(bar.get_x() + bar.get_width()/2., height, f'{height:.1f}', ha='center', va='bottom', fontsize=9) ax.set_ylabel('Mean Value', fontweight='bold') ax.set_xlabel('Category', fontweight='bold') ax.set_title('Average Value by Category', fontweight='bold') ax.grid(axis='y', alpha=0.3, linestyle='--') ax.set_axisbelow(True) plt.savefig('/workspace/bar_chart.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Line Chart (trends over time) ```python fig, ax = plt.subplots(figsize=(10, 5)) for i, col in enumerate(columns_to_plot): ax.plot(df["date"], df[col], label=col, color=COLORS[i], linewidth=2, marker='o', markersize=3, markevery=max(1, len(df)//20)) ax.set_ylabel('Values', fontweight='bold') ax.set_xlabel('Date', fontweight='bold') ax.set_title('Trends Over Time', fontweight='bold') ax.legend(frameon=True, shadow=False) ax.grid(True, alpha=0.3, linestyle='--') ax.set_axisbelow(True) plt.xticks(rotation=45, ha='right') plt.savefig('/workspace/line_chart.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Scatter Plot — Continuous Color (correlations) ```python fig, ax = plt.subplots(figsize=(8, 6)) scatter = ax.scatter(df["x"], df["y"], c=df["value"], cmap='viridis', s=40, alpha=0.7, edgecolors='black', linewidth=0.3) plt.colorbar(scatter, ax=ax, label='Value') # Optional: trend line z = np.polyfit(df["x"], df["y"], 1) ax.plot(df["x"].sort_values(), np.poly1d(z)(df["x"].sort_values()), "r--", linewidth=2, label=f'y={z[0]:.2f}x+{z[1]:.2f}') ax.set_xlabel('X', fontweight='bold') ax.set_ylabel('Y', fontweight='bold') ax.set_title('Correlation Analysis', fontweight='bold') ax.legend() ax.grid(True, alpha=0.3, linestyle='--') plt.savefig('/workspace/scatter_correlation.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Scatter Plot — Categorical Color (clusters) ```python fig, ax = plt.subplots(figsize=(8, 6)) for i, label in enumerate(sorted(df["cluster"].unique())): mask = df["cluster"] == label ax.scatter(df.loc[mask, "x"], df.loc[mask, "y"], c=COLORS[i], label=f'Cluster {label}', s=40, alpha=0.7) ax.set_xlabel('X', fontweight='bold') ax.set_ylabel('Y', fontweight='bold') ax.set_title('Cluster Visualization', fontweight='bold') ax.legend() ax.grid(True, alpha=0.3, linestyle='--') plt.savefig('/workspace/scatter_clusters.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Heatmap (correlation matrix or confusion matrix) ```python import seaborn as sns fig, ax = plt.subplots(figsize=(8, 7)) # corr_matrix = to_pd(df[numeric_cols].corr()) sns.heatmap(corr_matrix, annot=True, fmt='.2f', cmap='RdBu_r', center=0, square=True, linewidths=1, vmin=-1, vmax=1, cbar_kws={'label': 'Correlation'}, ax=ax) ax.set_title('Correlation Matrix', fontweight='bold') plt.savefig('/workspace/heatmap.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Histogram with KDE ```python fig, ax = plt.subplots(figsize=(8, 5)) ax.hist(df["value"], bins=30, color=COLORS[0], alpha=0.7, edgecolor='black', linewidth=0.5, density=True, label='Distribution') # Add KDE curve from scipy.stats import gaussian_kde kde = gaussian_kde(df["value"].dropna()) x_range = np.linspace(df["value"].min(), df["value"].max(), 200) ax.plot(x_range, kde(x_range), color=COLORS[1], linewidth=2, label='KDE') ax.set_xlabel('Value', fontweight='bold') ax.set_ylabel('Density', fontweight='bold') ax.set_title('Value Distribution', fontweight='bold') ax.legend() ax.grid(axis='y', alpha=0.3, linestyle='--') plt.savefig('/workspace/histogram.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Box Plot (compare groups) ```python fig, ax = plt.subplots(figsize=(8, 5)) groups = [df[df["group"] == g]["value"].values for g in group_names] bp = ax.boxplot(groups, labels=group_names, patch_artist=True, widths=0.6, showmeans=True, meanprops=dict(marker='D', markerfacecolor='red', markersize=6)) for i, patch in enumerate(bp['boxes']): patch.set_facecolor(COLORS[i % len(COLORS)]) patch.set_alpha(0.7) ax.set_ylabel('Value', fontweight='bold') ax.set_title('Distribution by Group', fontweight='bold') ax.grid(axis='y', alpha=0.3, linestyle='--') ax.set_axisbelow(True) plt.savefig('/workspace/boxplot.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Multi-Panel Analysis Summary Use this to create a single image with multiple charts — the most effective way to present a complete analysis. ```python fig, axes = plt.subplots(2, 2, figsize=(14, 10)) # Top-left: Distribution axes[0, 0].hist(df["value"], bins=30, color=COLORS[0], alpha=0.7, edgecolor='black', linewidth=0.5) axes[0, 0].set_title('Value Distribution', fontweight='bold') axes[0, 0].set_xlabel('Value') axes[0, 0].grid(axis='y', alpha=0.3, linestyle='--') # Top-right: Scatter axes[0, 1].scatter(df["x"], df["y"], c=COLORS[0], s=30, alpha=0.5) axes[0, 1].set_title('X vs Y', fontweight='bold') axes[0, 1].set_xlabel('X') axes[0, 1].set_ylabel('Y') axes[0, 1].grid(True, alpha=0.3, linestyle='--') # Bottom-left: Bar chart group_means = df.groupby("category")["value"].mean() axes[1, 0].bar(group_means.index, group_means.values, color=COLORS[:len(group_means)]) axes[1, 0].set_title('Mean by Category', fontweight='bold') axes[1, 0].set_xlabel('Category') axes[1, 0].grid(axis='y', alpha=0.3, linestyle='--') # Bottom-right: Box plot axes[1, 1].boxplot([df[df["category"] == c]["value"].values for c in categories], labels=categories, patch_artist=True) axes[1, 1].set_title('Distribution by Category', fontweight='bold') axes[1, 1].grid(axis='y', alpha=0.3, linestyle='--') fig.suptitle('Analysis Summary', fontsize=16, fontweight='bold') plt.savefig('/workspace/analysis_summary.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Feature Importance Chart (from cuML model) ```python fig, ax = plt.subplots(figsize=(8, max(4, len(feature_names) * 0.35))) # importances = to_pd(model.feature_importances_) sorted_idx = np.argsort(importances) ax.barh(np.array(feature_names)[sorted_idx], importances[sorted_idx], color=COLORS[0], edgecolor='black', linewidth=0.5) ax.set_xlabel('Importance', fontweight='bold') ax.set_title('Feature Importances', fontweight='bold') ax.grid(axis='x', alpha=0.3, linestyle='--') ax.set_axisbelow(True) plt.savefig('/workspace/feature_importance.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ### Confusion Matrix (from cuML classification) ```python import seaborn as sns fig, ax = plt.subplots(figsize=(7, 6)) # cm = confusion_matrix(to_pd(y_test), to_pd(predictions)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', square=True, xticklabels=class_names, yticklabels=class_names, linewidths=1, cbar_kws={'label': 'Count'}, ax=ax) ax.set_xlabel('Predicted', fontweight='bold') ax.set_ylabel('Actual', fontweight='bold') ax.set_title('Confusion Matrix', fontweight='bold') plt.savefig('/workspace/confusion_matrix.png', dpi=300, bbox_inches='tight', facecolor='white', edgecolor='none') plt.close() # IMPORTANT: call read_file("/workspace/.png") to display inline ``` ## Style Rules - Use `COLORS` palette (colorblind-safe) — never rely on color alone to distinguish elements - No pie charts (bar charts are always clearer) - No 3D plots (distort data perception) - Grid lines at `alpha=0.3, linestyle='--'` with `ax.set_axisbelow(True)` - Bold axis labels and titles (`fontweight='bold'`) - White background for all exports - 1-4 charts per analysis is typical; use multi-panel for more ## Output Guidelines - Save all charts to `/workspace/` as PNG - Print file paths after saving so the agent can reference them - For multi-panel summaries, use `figsize=(14, 10)` for 2×2 layouts - Keep chart titles descriptive but concise - Include units in axis labels when applicable --- name: gpu-document-processing description: Use when processing large PDFs, document collections, or bulk text extraction tasks that benefit from GPU-accelerated processing. Triggers when the user provides large documents or needs bulk document analysis. --- # GPU Document Processing Skill Process large documents and document collections using GPU-accelerated tools. This skill uses the sandbox-as-tool pattern: the agent runs on CPU for reasoning, and sends document processing work to a GPU-equipped environment. ## When to Use This Skill Use this skill when: - Processing large PDF files (50+ pages) - Analyzing collections of documents (10+ files) - Extracting structured data from unstructured documents - Performing bulk text extraction and chunking - Generating embeddings for large document sets - The user uploads or references large documents for analysis ## Architecture: Sandbox as Tool This skill follows the **sandbox-as-tool pattern** for GPU execution: 1. **Agent reasons on CPU** - planning, synthesis, report writing 2. **Processing sent to GPU sandbox** - document parsing, embedding, extraction 3. **Results returned to agent** - structured output for further analysis This separation ensures: - API keys stay outside the sandbox (security) - Agent state persists independently of processing jobs - Processing can be parallelized across documents - Cost-efficient: GPU used only during processing, not during reasoning ## Capabilities ### PDF Text Extraction Extract text content from PDF documents with layout preservation: - Headers, paragraphs, lists, and tables detected separately - Page numbers and section boundaries preserved - Multi-column layout handling ### Tabular Data Extraction Extract tables from documents into structured formats: - PDF tables to CSV/DataFrames using GPU-accelerated parsing - Automatic column type detection - Handles merged cells and multi-row headers ### Document Chunking Split large documents into meaningful chunks for analysis: - Semantic chunking (by topic/section boundaries) - Fixed-size chunking with overlap for embedding - Configurable chunk sizes (default: 512 tokens) ### Embedding Generation Generate vector embeddings for document chunks: - Uses NVIDIA NeMo Retriever NIM for GPU-accelerated embedding - Supports batch processing for large document sets - Compatible with standard vector stores (Milvus, ChromaDB) ## Workflow 1. **Receive document reference** from the orchestrator 2. **Determine processing type** (extraction, analysis, embedding) 3. **Send to GPU sandbox** for processing 4. **Collect structured results** (text, tables, embeddings) 5. **Write findings** to /shared/ for the orchestrator to synthesize ## Processing Large Document Collections For multiple documents: 1. Process documents in parallel batches (3-5 concurrent) 2. Extract key metadata first (title, date, author, page count) 3. Generate per-document summaries 4. Cross-reference findings across documents 5. Write consolidated findings with per-document citations ## Output Format When reporting document processing results: - Include document metadata (filename, pages, size) - Structure extracted content by section/chapter - Format tables as markdown tables - Include page references for all extracted content - Note any extraction quality issues (scanned images, corrupted pages) ## Integration with NVIDIA NIM For production deployments, GPU document processing can leverage: - **NVIDIA NeMo Retriever**: GPU-accelerated embedding and retrieval - **NVIDIA RAPIDS cuDF**: Tabular data processing from extracted tables - **NVIDIA Triton**: Scalable inference for document classification models See NVIDIA's NIM documentation for self-hosted deployment options. # swarm Path: `examples/repl_swarm/skills/swarm/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/examples/repl_swarm/skills/swarm/SKILL.md) # query-writing Path: `examples/text-to-sql-agent/skills/query-writing/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/examples/text-to-sql-agent/skills/query-writing/SKILL.md) # schema-exploration Path: `examples/text-to-sql-agent/skills/schema-exploration/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/examples/text-to-sql-agent/skills/schema-exploration/SKILL.md) # blog-post Path: `libs/cli/examples/deploy-content-writer/skills/blog-post/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/deploy-content-writer/skills/blog-post/SKILL.md) # social-media Path: `libs/cli/examples/deploy-content-writer/skills/social-media/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/deploy-content-writer/skills/social-media/SKILL.md) # arxiv-search Path: `libs/cli/examples/skills/arxiv-search/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/skills/arxiv-search/SKILL.md) # langgraph-docs Path: `libs/cli/examples/skills/langgraph-docs/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/skills/langgraph-docs/SKILL.md) # skill-creator Path: `libs/cli/examples/skills/skill-creator/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/skills/skill-creator/SKILL.md) # web-research Path: `libs/cli/examples/skills/web-research/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/examples/skills/web-research/SKILL.md) # note Path: `libs/cli/tests/unit_tests/deploy/fixtures/projects/subagent_with_local_skills/subagents/researcher/skills/note/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/tests/unit_tests/deploy/fixtures/projects/subagent_with_local_skills/subagents/researcher/skills/note/SKILL.md) # Summarize Skill Path: `libs/cli/tests/unit_tests/deploy/fixtures/projects/with_skills/skills/summarize/examples.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/tests/unit_tests/deploy/fixtures/projects/with_skills/skills/summarize/examples.md) # summarize Path: `libs/cli/tests/unit_tests/deploy/fixtures/projects/with_skills/skills/summarize/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/cli/tests/unit_tests/deploy/fixtures/projects/with_skills/skills/summarize/SKILL.md) # remember Path: `libs/code/deepagents_code/built_in_skills/remember/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/code/deepagents_code/built_in_skills/remember/SKILL.md) # skill-creator Path: `libs/code/deepagents_code/built_in_skills/skill-creator/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/code/deepagents_code/built_in_skills/skill-creator/SKILL.md) # arxiv-search Path: `libs/code/examples/skills/arxiv-search/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/code/examples/skills/arxiv-search/SKILL.md) # langgraph-docs Path: `libs/code/examples/skills/langgraph-docs/SKILL.md` [View Raw Content on GitHub](https://raw.githubusercontent.com/langchain-ai/deepagents/HEAD/libs/code/examples/skills/langgraph-docs/SKILL.md)

AI Agent Protocol & Instructions

Explore Related Technologies & Topics