Skip to main content
Community Actions allow you to access a library of AI actions created by the Local GPT community. These are pre-built prompts and system configurations you can install with one click. Community Actions

​
Accessing Community Actions

1

Open Local GPT Settings

Go to Obsidian Settings → Local GPT
2

Find Community Actions

Scroll to the “Community Actions” section
3

Click 'Browse Community Actions'

This opens the Community Actions modal
new Setting(containerEl)
  .setName(I18n.t("settings.communityActions"))
  .setDesc(I18n.t("settings.communityActionsOpenDesc"))
  .addButton((button) => {
    button
      .setButtonText(I18n.t("settings.communityActionsOpen"))
      .setCta()
      .onClick(() => openCommunityActionsModal());
  });

​
Browsing Actions

The Community Actions modal provides:

Language Filter

Filter actions by language (English, Spanish, etc.)

Search

Fuzzy search across action names, descriptions, and prompts

Scoring

Actions are ranked by community reactions (upvotes)

Status Badges

See which actions are installed, modified, or have conflicts

​
Action Information

Each community action displays:
  • Name: The action’s title
  • Description: What the action does (if provided)
  • Author: Who created the action
  • Score: Community rating based on reactions
  • Tags: Whether the action replaces selected text
  • Status: Installed, Modified, or Available
export interface CommunityAction {
  id: string;
  name: string;
  language: string;
  description?: string;
  prompt?: string;
  system?: string;
  replace?: boolean;
  author: string;
  authorUrl?: string;
  commentUrl?: string;
  score: number;
  createdAt?: string;
  updatedAt?: string;
}

​
Installing Actions

1

Find an action

Browse or search for the action you want
2

Click 'Install'

The action will be added to your actions list
3

Use the action

Access it via the context menu or action palette
Installed actions appear in your regular actions list and can be used immediately.

​
Automatic Updates

Community actions are automatically updated to the latest version when you browse the library.

​
How Auto-Update Works

  1. When you open Community Actions, Local GPT fetches the latest versions
  2. Installed actions are compared with the community versions
  3. If a newer version exists and you haven’t modified the action, it updates automatically
  4. A status message shows how many actions were updated
const syncCommunityActions = async (
  actions: CommunityAction[],
): Promise<{ updated: number; skipped: number }> => {
  const lookup = buildCommunityActionsLookup(
    this.plugin.settings.actions,
  );
  let updated = 0;
  let skipped = 0;

  actions.forEach((action) => {
    const localAction = findCommunityActionLink(action, lookup);
    if (!localAction) return;

    const localSignature = buildCommunityActionSignature(localAction);
    const remoteSignature = buildCommunityActionSignature(action);
    
    // Check if action was modified locally
    if (isCommunityActionModified(localAction, localSignature)) {
      skipped++;
      return;
    }
    
    // Update if signatures differ
    if (localSignature !== remoteSignature) {
      applyCommunityActionUpdate(localAction, action);
      updated++;
    }
  });

  return { updated, skipped };
};

​
Preventing Auto-Updates

To stick with a specific version or preserve your changes:
Simply modify the Prompt or System Prompt of the action. This will disable automatic updates for that action.
Changing only the Name does NOT prevent auto-updates. You must modify the prompt or system prompt.
const dropCommunityLinkIfModified = (action: LocalGPTAction) => {
  if (!action.community?.hash) {
    return;
  }
  const localSignature = buildCommunityActionSignature(action);
  if (localSignature !== action.community.hash) {
    delete action.community;
  }
};

​
Action Status Badges

​
Installed
badge
Action is installed and up-to-date with the community version
​
Modified
badge
You’ve modified the action locally. Auto-updates are disabled.You can click “Update” to overwrite your changes with the community version.
​
In List
badge
You have a different action with the same name. Installing will replace it.

​
Sharing Your Own Actions

You can contribute your actions to the community:
1

Create your action

Build and test your action in Local GPT
2

Export the action

Click the copy button next to your action
3

Share on GitHub

Post your action in the Community Actions Discussion

​
Action Format

When you copy an action, it’s formatted like this: 
Name: Explain Like I'm Five ✂️
System: You are a patient teacher who explains complex topics in simple terms using analogies and examples that a 5-year-old would understand. ✂️
Prompt: Explain the following concept in simple terms: ✂️
Replace: false ✂️
Language: en
The ✂️ separator is used to delimit fields. Don’t remove it when sharing.
const buildSharingString = (action: LocalGPTAction) => {
  const detectedLanguage = detectDominantLanguage(
    [action.name, action.system, action.prompt]
      .filter((value): value is string => Boolean(value))
      .join("\n"),
  );
  const resolvedLanguage = normalizeLanguageCode(
    detectedLanguage === "unknown"
      ? defaultCommunityActionsLanguage
      : detectedLanguage,
  );
  const replaceValue = action.replace
    ? `${sharingFieldLabels.replace}${action.replace}`
    : "";

  return [
    action.name && `${sharingFieldLabels.name}${action.name}`,
    action.system && `${sharingFieldLabels.system}${action.system}`,
    action.prompt && `${sharingFieldLabels.prompt}${action.prompt}`,
    replaceValue,
    `${sharingFieldLabels.language}${resolvedLanguage}`,
  ]
    .filter(Boolean)
    .join(` ${SEPARATOR}\n`);
};

​
Quick Add Actions

You can also paste community action strings directly into the Quick Add field:
1

Copy an action string

Get the formatted action text from GitHub or another user
2

Open Local GPT Settings

Go to the Actions section
3

Paste into Quick Add

The action will be parsed and added automatically
const quickAdd = new Setting(containerEl)
  .setName(I18n.t("settings.quickAdd"))
  .addText((text) => {
    text.onChange(async (value) => {
      const parts = value
        .split(SEPARATOR)
        .map((part) => part.trim())
        .filter(Boolean);
      
      const quickAddAction: LocalGPTAction = {
        name: "",
        prompt: "",
      };

      for (const part of parts) {
        const entry = sharingEntries.find(([, label]) =>
          part.startsWith(label),
        );
        const key = entry?.[0];
        const label = entry?.[1];
        const rawValue = label
          ? part.slice(label.length).trim()
          : "";
        if (!key || !rawValue) continue;
        
        const handler = quickAddHandlers[key];
        if (handler) {
          handler(rawValue, quickAddAction);
        }
      }

      if (quickAddAction.name) {
        await this.addNewAction(quickAddAction);
        text.setValue("");
        this.display();
      }
    });
  });

​
Community Action Sources

Community actions are fetched from:
  • GitHub Discussions: Discussion #89
  • Community reactions: Actions are scored based on positive/negative reactions
const DISCUSSION_COMMENTS_URL =
  "https://api.github.com/repos/pfrankov/obsidian-local-gpt/discussions/89/comments";

static async getCommunityActions(options?: {
  forceRefresh?: boolean;
}): Promise<CommunityAction[]> {
  if (this.cache && !forceRefresh) {
    return this.cache;
  }

  const { actions, failed } = await this.fetchCommunityActions();
  if (failed && this.cache) {
    return this.cache;
  }
  
  this.cache = actions;
  return actions;
}

​
Scoring System

Actions are ranked by their score, calculated from GitHub reactions: Positive reactions (+1 each):
  • 👍 Thumbs up
  • ❤️ Heart
  • 🎉 Hooray
  • 🚀 Rocket
  • 👀 Eyes
  • 😄 Laugh
Negative reactions (-1 each):
  • 👎 Thumbs down
  • 😕 Confused
private static getReactionScore(
  reactions?: GitHubDiscussionComment["reactions"],
): number {
  if (!reactions) return 0;
  
  const positive = POSITIVE_REACTIONS.reduce((total, key) => {
    return total + (reactions[key] ?? 0);
  }, 0);
  const negative = NEGATIVE_REACTIONS.reduce((total, key) => {
    return total + (reactions[key] ?? 0);
  }, 0);
  
  return positive - negative;
}
React to actions on GitHub to help others discover quality prompts!

​
Search and Filter

​
Language Filtering

Actions are tagged by language. Select your preferred language from the dropdown to see relevant actions. Search matches against:
  1. Action name (highest priority)
  2. Description
  3. Prompt text
  4. System prompt
const getCommunityActionSearchRank = (
  action: CommunityAction,
  query: string,
): number | null => {
  const fields = [
    action.name,
    action.description,
    action.prompt,
    action.system,
  ];
  
  for (let i = 0; i < fields.length; i++) {
    const value = fields[i];
    if (!value) continue;
    
    const normalized = normalizeSearchValue(value);
    if (normalized && fuzzyMatch(normalized, query)) {
      return i;  // Lower index = higher priority
    }
  }
  return null;
};

​
Troubleshooting

  • Check your internet connection
  • Click “Refresh” to retry fetching
  • Cached actions will be used if available
  • You may have a naming conflict
  • Check if you already have an action with the same name
  • The status badge will indicate conflicts
  • Ensure you haven’t modified the action’s prompts
  • Check that the action has the community badge
  • Try refreshing the community actions list
  • Make sure you modify the Prompt or System Prompt
  • Changing only the name doesn’t disable updates
  • The “Modified” badge should appear after editing

​
Next Steps

Creating Custom Actions

Learn how to create your own actions from scratch

Contributing

Contribute your actions to help the community

Build docs developers (and LLMs) love

Get started for freeTalk to us