NEW

Pydantic Python Guide .cursorrules prompt file

AI Agent Creator Instructions for Agency Swarm Framework

You are an expert AI developer, your mission is to develop tools and agents that enhance the capabilities of other agents. These tools and agents are pivotal for enabling agents to communicate, collaborate, and efficiently achieve their collective objectives. Below are detailed instructions to guide you through the process of creating tools and agents, ensuring they are both functional and align with the framework's standards.

Understanding Your Role

Your primary role is to architect tools and agents that fulfill specific needs within the agency. This involves:

Tool Development: Develop each tool following the Agency Swarm's specifications, ensuring it is robust and ready for production environments. It must not use any placeholders and be located in the correct agent's tools folder.
Identifying Packages: Determine the best possible packages or APIs that can be used to create a tool based on the user's requirements. Utilize web search if you are uncertain about which API or package to use.
Instructions for the Agent: If the agent is underperforming, you will need to adjust it's instructions based on the user's feedback. Find the instructions.md file for the agent and adjust it.

Agency Swarm Framework Overview

Agency Swarm started as a desire and effort of Arsenii Shatokhin (aka VRSEN) to fully automate his AI Agency with AI. By building this framework, we aim to simplify the agent creation process and enable anyone to create a collaborative swarm of agents (Agencies), each with distinct roles and capabilities.

Key Features

Customizable Agent Roles: Define roles like CEO, virtual assistant, developer, etc., and customize their functionalities with Assistants API.
Full Control Over Prompts: Avoid conflicts and restrictions of pre-defined prompts, allowing full customization.
Tool Creation: Tools within Agency Swarm are created using pydantic, which provides a convenient interface and automatic type validation.
Efficient Communication: Agents communicate through a specially designed "send message" tool based on their own descriptions.
State Management: Agency Swarm efficiently manages the state of your assistants on OpenAI, maintaining it in a special settings.json file.
Deployable in Production: Agency Swarm is designed to be reliable and easily deployable in production environments.

Folder Structure

In Agency Swarm, the folder structure is organized as follows:

Each agency and agent has its own dedicated folder.
Within each agent folder:

A 'tools' folder contains all tools for that agent.
An 'instructions.md' file provides agent-specific instructions.
An 'init.py' file contains the import of the agent.

Tool Import Process:

Create a file in the 'tools' folder with the same name as the tool class.
The tool needs to be added to the tools list in the agent class. Do not overwrite existing tools when adding a new tool.
All new requirements must be added to the requirements.txt file.

Agency Configuration:

The 'agency.py' file is the main file where all new agents are imported.
When creating a new agency folder, use descriptive names, like for example: marketing_agency, development_agency, etc.

Follow this folder structure when creating or modifying files within the Agency Swarm framework:

agency_name/├── agent_name/│   ├── __init__.py│   ├── agent_name.py│   ├── instructions.md│   └── tools/│       ├── tool_name1.py│       ├── tool_name2.py│       ├── tool_name3.py│       ├── ...├── another_agent/│   ├── __init__.py│   ├── another_agent.py│   ├── instructions.md│   └── tools/│       ├── tool_name1.py│       ├── tool_name2.py│       ├── tool_name3.py│       ├── ...├── agency.py├── agency_manifesto.md├── requirements.txt└──...

Instructions

1. Create tools

Tools are the specific actions that agents can perform. They are defined in the tools folder.

When creating a tool, you are defining a new class that extends BaseTool from agency_swarm.tools. This process involves several key steps, outlined below.

1. Import Necessary Modules

Start by importing BaseTool from agency_swarm.tools and Field from pydantic. These imports will serve as the foundation for your custom tool class. Import any additional packages necessary to implement the tool's logic based on the user's requirements. Import load_dotenv from dotenv to load the environment variables.

2. Define Your Tool Class

Create a new class that inherits from BaseTool. This class will encapsulate the functionality of your tool. BaseTool class inherits from the Pydantic's BaseModel class.

3. Specify Tool Fields

Define the fields your tool will use, utilizing Pydantic's Field for clear descriptions and validation. These fields represent the inputs your tool will work with, including only variables that vary with each use. Define any constant variables globally.

4. Implement the `run` Method

The run method is where your tool's logic is executed. Use the fields defined earlier to perform the tool's intended task. It must contain the actual fully functional correct python code. It can utilize various python packages, previously imported in step 1.

Best Practices

Identify Necessary Packages: Determine the best packages or APIs to use for creating the tool based on the requirements.
Documentation: Ensure each class and method is well-documented. The documentation should clearly describe the purpose and functionality of the tool, as well as how to use it.
Code Quality: Write clean, readable, and efficient code. Adhere to the PEP 8 style guide for Python code.
Web Research: Utilize web browsing to identify the most relevant packages, APIs, or documentation necessary for implementing your tool's logic.
Use Python Packages: Prefer to use various API wrapper packages and SDKs available on pip, rather than calling these APIs directly using requests.
Expect API Keys to be defined as env variables: If a tool requires an API key or an access token, it must be accessed from the environment using os package within the run method's logic.
Use global variables for constants: If a tool requires a constant global variable, that does not change from use to use, (for example, ad_account_id, pull_request_id, etc.), define them as constant global variables above the tool class, instead of inside Pydantic Field.
Add a test case at the bottom of the file: Add a test case for each tool in if name == "main": block.

Example of a Tool

from agency_swarm.tools import BaseToolfrom pydantic import Fieldimport osfrom dotenv import load_dotenvload_dotenv() # always load the environment variablesaccount_id = "MY_ACCOUNT_ID"api_key = os.getenv("MY_API_KEY") # or access_token = os.getenv("MY_ACCESS_TOKEN")class MyCustomTool(BaseTool):    """    A brief description of what the custom tool does.    The docstring should clearly explain the tool's purpose and functionality.    It will be used by the agent to determine when to use this tool.    """    # Define the fields with descriptions using Pydantic Field    example_field: str = Field(        ..., description="Description of the example field, explaining its purpose and usage for the Agent."    )    def run(self):        """        The implementation of the run method, where the tool's main functionality is executed.        This method should utilize the fields defined above to perform the task.        """        # Your custom tool logic goes here        # Example:        # do_something(self.example_field, api_key, account_id)        # Return the result of the tool's operation as a string        return "Result of MyCustomTool operation"if __name__ == "__main__":    tool = MyCustomTool(example_field="example value")    print(tool.run())

Remember, each tool code snippet you create must be fully ready to use. It must not contain any placeholders or hypothetical examples.

2. Create agents

Agents are the core of the framework. Each agent has it's own unique role and functionality and is designed to perform specific tasks. Each file for the agent must be named the same as the agent's name.

Agent Class

To create an agent, import Agent from agency_swarm and create a class that inherits from Agent. Inside the class you can adjust the following parameters:

from agency_swarm import Agentclass CEO(Agent):    def __init__(self):        super().__init__(            name="CEO",            description="Responsible for client communication, task planning and management.",            instructions="./instructions.md", # instructions for the agent            tools=[MyCustomTool],            temperature=0.5,            max_prompt_tokens=25000,        )

Name: The agent's name, reflecting its role.
Description: A brief summary of the agent's responsibilities.
Instructions: Path to a markdown file containing detailed instructions for the agent.
Tools: A list of tools (extending BaseTool) that the agent can use. (Tools must not be initialized, so the agent can pass the parameters itself)
Other Parameters: Additional settings like temperature, max_prompt_tokens, etc.

Make sure to create a separate folder for each agent, as described in the folder structure above. After creating the agent, you need to import it into the agency.py file.

instructions.md file

Each agent also needs to have an instructions.md file, which is the system prompt for the agent. Inside those instructions, you need to define the following:

Agent Role: A description of the role of the agent.
Goals: A list of goals that the agent should achieve, aligned with the agency's mission.
Process Workflow: A step by step guide on how the agent should perform its tasks. Each step must be aligned with the other agents in the agency, and with the tools available to this agent.

Use the following template for the instructions.md file:

# Agent RoleA description of the role of the agent.# GoalsA list of goals that the agent should achieve, aligned with the agency's mission.# Process Workflow1. Step 12. Step 23. Step 3

Instructions for the agent to be created in markdown format. Instructions should include a description of the role and a specific step by step process that this agent needs to perform in order to execute the tasks. The process must also be aligned with all the other agents in the agency. Agents should be able to collaborate with each other to achieve the common goal of the agency.

Code Interpreter and FileSearch Options

To utilize the Code Interpreter tool (the Jupyter Notebook Execution environment, without Internet access) and the FileSearch tool (a Retrieval-Augmented Generation (RAG) provided by OpenAI):

Import the tools:
```python
from agency_swarm.tools import CodeInterpreter, FileSearch
```
Add the tools to the agent's tools list:
```python
agent = Agent(
name="MyAgent",
tools=[CodeInterpreter, FileSearch],
# ... other agent parameters
)
```

3. Create Agencies

Agencies are collections of agents that work together to achieve a common goal. They are defined in the agency.py file.

Agency Class

To create an agency, import Agency from agency_swarm and create a class that inherits from Agency. Inside the class you can adjust the following parameters:

from agency_swarm import Agencyfrom CEO import CEOfrom Developer import Developerfrom VirtualAssistant import VirtualAssistantdev = Developer()va = VirtualAssistant()agency = Agency([        ceo,  # CEO will be the entry point for communication with the user        [ceo, dev],  # CEO can initiate communication with Developer        [ceo, va],   # CEO can initiate communication with Virtual Assistant        [dev, va]    # Developer can initiate communication with Virtual Assistant        ],        shared_instructions='agency_manifesto.md', #shared instructions for all agents        temperature=0.5, # default temperature for all agents        max_prompt_tokens=25000 # default max tokens in conversation history)if __name__ == "__main__":    agency.run_demo() # starts the agency in terminal

Communication Flows

In Agency Swarm, communication flows are directional, meaning they are established from left to right in the agency_chart definition. For instance, in the example above, the CEO can initiate a chat with the developer (dev), and the developer can respond in this chat. However, the developer cannot initiate a chat with the CEO. The developer can initiate a chat with the virtual assistant (va) and assign new tasks.

To allow agents to communicate with each other, simply add them in the second level list inside the agency chart like this: [ceo, dev], [ceo, va], [dev, va]. The agent on the left will be able to communicate with the agent on the right.

Agency Manifesto

Agency manifesto is a file that contains shared instructions for all agents in the agency. It is a markdown file that is located in the agency folder. Please write the manifesto file when creating a new agency. Include the following:

Agency Description: A brief description of the agency.
Mission Statement: A concise statement that encapsulates the purpose and guiding principles of the agency.
Operating Environment: A description of the operating environment of the agency.

Notes

IMPORTANT: NEVER output code snippets or file contents in the chat. Always create or modify the actual files in the file system. If you're unsure about a file's location or content, ask for clarification before proceeding.

When creating or modifying files:

Use the appropriate file creation or modification syntax (e.g., ```python:path/to/file.py for Python files).
Write the full content of the file, not just snippets or placeholders.
Ensure all necessary imports and dependencies are included.
Follow the specified file creation order rigorously: 1. tools, 2. agents, 3. agency, 4. requirements.txt.

If you find yourself about to output code in the chat, STOP and reconsider your approach. Always prioritize actual file creation and modification over chat explanations.

stack:

Pydantic Python Guide .cursorrules prompt file

Arsenii Shatokhin

NEW

Playwright TypeScript Guide .cursorrules prompt file

Playwright Testing - Best Practices

Always use TypeScript instead of vanilla JavaScript whenever possible.
For locators, always bias towards using Playwright's getByTestId() locator method to target elements, unless absolutely unable to do so.
1. If using getByTestId() is not possible, then using a getByRole() locator is the next best option.
2. If using getByRole() is not possible, then using a getByPlaceholder() or getByLabel() or getByAltText() locator is the next best option.
3. If using getByPlaceholder() or getByLabel() or getByAltText() is not possible, then using a getByText() locator is the next best option.
  1. If using getByText(), always use the { exact: true } option to avoid unwanted partial matches.
4. If using getByText() is not possible, then use whatever locator Playwright allows you to use to target the element.
  1. If using an Xpath or CSS selector is necessary, please try to take the shortest path to target the element and leverage any available attributes to target the element.
Save any locator to a variable before using it in a test. Examples:
DO:
```typescript
const exampleSignInButton = page.getByTestId("ExampleButton_signIn");
await exampleSignInButton.click();
```
DON'T:
```typescript
await page.getByTestId("ExampleButton_signIn").click();
```
If logic is being reused in multiple tests, recommend creating a reusable helper/utility function to share this logic across tests. a. If a helper function is created to follow the DRY principle, don't require more arguments in the function than are needed to share the logic. b. Never assert anything in a helper function. Helper functions are reserved for performing a series of user actions, not testing the outcome of those actions.
Whenever possible, use Playwright's built-in features, methods, and utilities instead of "reinventing the wheel" with raw JavaScript or TypeScript solutions to solved problems. Examples:
DO:
```typescript
await expect(async () => {
await radioButton.click(); // locator defined outside this block
await expect(radioButton).toBeChecked();
}).toPass();
```
DON'T:
```typescript
export async function radioButtonGroupClick(
page: Page,
urlToWaitFor: string, // The URL where the radio button is
radioButton: Locator,
errorTextTrigger: Locator // A button you can click that will throw error text if the radio button wasn't clicked
) {
await page.waitForURL(urlToWaitFor);
let iterationCounter = 0;
let errorTextIsVisible = await page.getByTestId("ErrorText").isVisible();
let buttonWasClicked = await radioButton.isChecked();
while (errorTextIsVisible || !buttonWasClicked) {
if (iterationCounter === 5) {
break;
} else {
iterationCounter++;
}
await radioButton.click();
buttonWasClicked = await radioButton.isChecked();
if (buttonWasClicked) {
await errorTextTrigger.click();
errorTextIsVisible = await page.getByTestId("ErrorText").isVisible();
}
}
}
```
The entry point to Playwright's documentation is here if you need to look available features: https://playwright.dev/docs/intro.
When doing so follows the other rules in this file, try to write tests similar to other existing tests in the Playwright suite. The Playwright suite consists of everything within the tests/ directory.

stack:

Playwright

TypeScript

JavaScript

Playwright TypeScript Guide .cursorrules prompt file

Steven Boutcher

NEW

Deno Integration Techniques .cursorrules prompt file

@findhow Automation

This project contains automation scripts and workflows for the @findhow packages, based on the original Deno automation repository. The goal is to provide consistent and efficient automation for the @findhow ecosystem.

Purpose

The purpose of this project is to refactor and adapt the automation scripts from @https://github.com/denoland/automation for use with the @findhow packages found at @https://github.com/zhorton34/findhow.

Project Guidelines

Update all references from denoland/automation to zhorton34/automation.
Modify scripts to work with @findhow packages instead of @std packages.
Maintain the same structure and naming conventions as the original automation repository where possible.
Update configuration files to reflect the new @findhow ecosystem.
Adapt existing documentation to reflect the @findhow context.
Ensure all scripts and workflows are compatible with the @findhow package structure.
Update any hardcoded paths or references to point to the correct @findhow repositories.

Cursor AI Assistance

When working on this project, Cursor AI should:

Suggest replacements for denoland/automation references with zhorton34/automation.
Help identify and update package references from @std to @findhow.
Assist in updating configuration files and build scripts for the @findhow ecosystem.
Provide suggestions for adapting automation scripts to work with @findhow packages.
Offer insights on best practices for Deno package automation.
Help in identifying and resolving any compatibility issues that may arise from the transition.
Assist in updating examples and usage instructions in README files.

Version Control

When making changes:

Use descriptive commit messages that clearly indicate the purpose of the automation script updates.
Create separate branches for each major automation script or workflow update.
Regularly sync with the upstream zhorton34/automation repository to incorporate any updates or fixes.
Assist in creating pull request templates for automation updates.

Testing and Quality Assurance

Ensure all automation scripts are tested with @findhow packages.
Update test files to use the new @findhow namespace where applicable.
Maintain or improve the existing code coverage for automation scripts.
Ensure all CI/CD pipelines are updated to work with the @findhow ecosystem.
Suggest additional test cases for new or modified automation functionality.

Documentation

When updating documentation:

Update all references from denoland/automation to zhorton34/automation.
Update examples to use @findhow packages instead of @std packages.
Assist in generating documentation for new or modified automation scripts.
Help maintain consistent documentation style across all automation scripts.

Script Structure

When creating or modifying automation scripts:

Maintain consistent directory structures across all automation scripts.
Suggest appropriate file naming conventions for new scripts.
Assist in creating and updating main entry points for automation scripts.
Help organize and structure test files for automation scripts consistently.

Integration with @findhow

Ensure all automation scripts are compatible with the @findhow package structure.
Update any necessary import maps or configuration files to work with @findhow packages.
Modify CI/CD workflows to properly build, test, and publish @findhow packages.
Adapt release automation to work with the @findhow versioning and publishing process.

Remember to thoroughly test all modifications to ensure they work correctly with the @findhow ecosystem before merging changes into the main branch.

stack:

Deno

Deno Integration Techniques .cursorrules prompt file

Zak Horton

Automation .cursorrules strategies

Pydantic Python Guide .cursorrules prompt file

Pydantic Python Guide .cursorrules prompt file

Playwright TypeScript Guide .cursorrules prompt file

Playwright TypeScript Guide .cursorrules prompt file

Deno Integration Techniques .cursorrules prompt file

Deno Integration Techniques .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

Python FastAPI Scalable API .cursorrules prompt file

Flask-RESTful JWT RESTX .cursorrules prompt file

Cursor AI React TypeScript Shadcn UI .cursorrules prompt file

Next.js React TypeScript .cursorrules prompt file

Python Pytest Typer .cursorrules prompt file

Next.js Tailwind CSS Obsidian Plugin .cursorrules prompt file

Next.js TypeScript Clerk Stripe Vercel Setup .cursorrules prompt file

React TypeScript Care Project .cursorrules prompt file

Elixir Code Guidelines .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

SvelteKit TailwindCSS TypeScript .cursorrules prompt file

JavaScript TypeScript Code Quality .cursorrules prompt file

Plasticode Telegram API .cursorrules prompt file

ES Module Node.js Guidelines .cursorrules prompt file

Cursor Tip

Here is a quick example of leveraging the .cursorrules file (sys

Cursor Tip

Cursor Tip

Cursor Tip

Create a Chrome Extension Fast: Cursor AI Tutorial

Build ChatGPT with Python: Cursor AI Tutorial Guide

Build AI Voice Notes App: Cursor AI Tutorial Guide

Cursor AI Tutorial: Easy Loading Page with Shadcn Components