Communitygithub.com

majiayu000/claude-skill-registry

Tableau de bord analytique multi-projets. Agrégation d'indicateurs clés de performance (KPI) sur plusieurs projets, suivi de la santé du portefeuille, comparaison des performances et aide à la décision stratégique.

Qu'est-ce que claude-skill-registry ?

Ce skill définit un tableau de bord de portefeuille complet conçu pour les chefs de projet, les responsables de programme et la direction exécutive dans le secteur de la construction. Il permet d'agréger et d'analyser les données de plusieurs projets de construction simultanément, offrant une visibilité au niveau du portefeuille sur les indicateurs clés de performance tels que le coût, le calendrier, la sécurité, la qualité et le risque. Sa mise en œuvre technique inclut des classes Python (dataclasses) pour la saisie des métriques de projet et un système automatisé d'évaluation de la santé (vert, jaune, rouge, gris) qui déclenche des alertes lorsque les dépassements de budget ou de délai dépassent des seuils configurables. L'outil prend en charge le suivi des tendances historiques (captures instantanées), les comparaisons entre projets, l'identification des risques et la prévision des besoins de trésorerie sur plusieurs mois. Il est particulièrement utile pour appuyer les décisions stratégiques d'allocation des ressources et peut être intégré dans n'importe quel pipeline de gestion de projet où les données sont importées via des dictionnaires Python.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry/tree/HEAD/skills/analysis/portfolio-dashboard

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Tableau de bord de portefeuille

Vue d'ensemble

Agrégez et analysez les données sur plusieurs projets de construction pour une visibilité au niveau du portefeuille. Suivez les KPI, identifiez les tendances, comparez les performances des projets et soutenez les décisions stratégiques d'allocation des ressources.

Cadre d'analyse du portefeuille

┌─────────────────────────────────────────────────────────────────┐
│                  TABLEAU DE BORD DU PORTEFEUILLE                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  PROJET A    PROJET B    PROJET C    PROJET D                   │
│     ↓             ↓            ↓            ↓                   │
│  ┌─────────────────────────────────────────────┐                │
│  │           AGRÉGATION DES DONNÉES             │                │
│  │  Coût | Calendrier | Sécurité | Qualité | Risque  │
│  └─────────────────────────────────────────────┘                │
│                         ↓                                        │
│  ┌─────────────────────────────────────────────┐                │
│  │          KPI DU PORTEFEUILLE                 │                │
│  │  📊 Valeur totale    📈 % dans les délais    │                │
│  │  💰 % dans le budget  🛡️ Taux de sécurité   │                │
│  │  ⚠️ Score de risque  📋 Utilisation des ressources │          │
│  └─────────────────────────────────────────────┘                │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Mise en œuvre technique

from dataclasses import dataclass, field
from typing import List, Dict, Optional, Tuple
from datetime import datetime, timedelta
from enum import Enum
import statistics

class StatutProjet(Enum):
    PLANIFICATION = "planification"
    ACTIF = "actif"
    EN_SUSPENS = "en_suspens"
    TERMINE = "termine"
    ANNULE = "annule"

class StatutSante(Enum):
    VERT = "vert"       # Dans les temps
    JAUNE = "jaune"     # À risque
    ROUGE = "rouge"     # Critique
    GRIS = "gris"       # Non démarré/En suspens

@dataclass
class MetriquesProjet:
    id_projet: str
    nom_projet: str
    statut: StatutProjet
    valeur_contrat: float
    pourcentage_acheve: float

    # Calendrier
    debut_prevue: datetime
    fin_prevue: datetime
    debut_reelle: Optional[datetime]
    fin_previsionnelle: datetime
    ecart_calendrier_jours: int = 0

    # Coût
    budget: float
    cout_reel: float
    cout_previsionnel: float
    ecart_cout: float = 0.0
    ipc: float = 1.0
    ical: float = 1.0

    # Sécurité
    incidents_declarables: int = 0
    heures_total: float = 0
    trir: float = 0.0

    # Qualité
    defauts_ouverts: int = 0
    cout_reprise: float = 0.0

    # Risque
    score_risque: float = 0.0
    risques_critiques: int = 0

    @property
    def sante(self) -> StatutSante:
        """Déterminer la santé globale du projet."""
        if self.statut in [StatutProjet.EN_SUSPENS, StatutProjet.ANNULE]:
            return StatutSante.GRIS

        # Critique si significativement hors budget/calendrier
        if self.ipc < 0.85 or self.ical < 0.85 or self.risques_critiques > 3:
            return StatutSante.ROUGE

        # À risque si modérément hors piste
        if self.ipc < 0.95 or self.ical < 0.95 or self.risques_critiques > 0:
            return StatutSante.JAUNE

        return StatutSante.VERT

@dataclass
class ResumePortefeuille:
    date_rapport: datetime
    total_projets: int
    projets_actifs: int
    valeur_contrat_total: float
    budget_total: float
    cout_reel_total: float
    cout_previsionnel_total: float

    # Performance
    ipc_moyen: float
    ical_moyen: float
    pourcentage_dans_budget: float
    pourcentage_dans_delais: float

    # Sécurité
    trir_portefeuille: float
    total_incidents: int

    # Répartition de la santé
    nb_vert: int
    nb_jaune: int
    nb_rouge: int

    # Tendances
    tendance_cout: str
    tendance_calendrier: str

@dataclass
class ComparaisonProjets:
    metrique: str
    projets: Dict[str, float]
    moyenne: float
    meilleur: Tuple[str, float]
    pire: Tuple[str, float]

class TableauBordPortefeuille:
    """Analytique multi-projets du portefeuille."""

    # Seuils de santé
    SEUILS = {
        "avertissement_ipc": 0.95,
        "critique_ipc": 0.85,
        "avertissement_ical": 0.95,
        "critique_ical": 0.85,
        "avertissement_trir": 2.0,
        "avertissement_score_risque": 7.0
    }

    def __init__(self, nom_portefeuille: str):
        self.nom_portefeuille = nom_portefeuille
        self.projets: Dict[str, MetriquesProjet] = {}
        self.captures: List[Dict] = []  # Données historiques

    def ajouter_projet(self, metriques: MetriquesProjet):
        """Ajouter ou mettre à jour un projet dans le portefeuille."""
        self.projets[metriques.id_projet] = metriques

    def importer_projets(self, donnees_projets: List[Dict]) -> int:
        """Importer plusieurs projets à partir de données."""
        compteur = 0
        for p in donnees_projets:
            metriques = MetriquesProjet(
                id_projet=p['id'],
                nom_projet=p['name'],
                statut=StatutProjet(p.get('status', 'actif')),
                valeur_contrat=p['contract_value'],
                pourcentage_acheve=p.get('percent_complete', 0),
                debut_prevue=p['planned_start'],
                fin_prevue=p['planned_end'],
                debut_reelle=p.get('actual_start'),
                fin_previsionnelle=p.get('forecast_end', p['planned_end']),
                budget=p['budget'],
                cout_reel=p.get('actual_cost', 0),
                cout_previsionnel=p.get('forecast_cost', p['budget']),
                ipc=p.get('cpi', 1.0),
                ical=p.get('spi', 1.0),
                incidents_declarables=p.get('incidents', 0),
                heures_total=p.get('total_hours', 0),
                score_risque=p.get('risk_score', 0),
                risques_critiques=p.get('critical_risks', 0)
            )

            # Calculer les métriques dérivées
            metriques.ecart_cout = metriques.budget - metriques.cout_reel
            metriques.ecart_calendrier_jours = (metriques.fin_prevue - metriques.fin_previsionnelle).days

            if metriques.heures_total > 0:
                metriques.trir = (metriques.incidents_declarables * 200000) / metriques.heures_total

            self.ajouter_projet(metriques)
            compteur += 1

        return compteur

    def obtenir_projets_actifs(self) -> List[MetriquesProjet]:
        """Obtenir la liste des projets actifs."""
        return [p for p in self.projets.values()
                if p.statut == StatutProjet.ACTIF]

    def calculer_resume_portefeuille(self) -> ResumePortefeuille:
        """Calculer les métriques de résumé au niveau du portefeuille."""
        actifs = self.obtenir_projets_actifs()
        tous_les_projets = list(self.projets.values())

        if not tous_les_projets:
            return None

        # Totaux
        total_contrat = sum(p.valeur_contrat for p in tous_les_projets)
        total_budget = sum(p.budget for p in tous_les_projets)
        total_reel = sum(p.cout_reel for p in tous_les_projets)
        total_previsionnel = sum(p.cout_previsionnel for p in tous_les_projets)

        # Moyennes de performance (pondérées par le budget)
        if total_budget > 0:
            ipc_moyen = sum(p.ipc * p.budget for p in actifs) / sum(p.budget for p in actifs) if actifs else 1.0
            ical_moyen = sum(p.ical * p.budget for p in actifs) / sum(p.budget for p in actifs) if actifs else 1.0
        else:
            ipc_moyen = ical_moyen = 1.0

        # Pourcentages dans le budget/délais
        dans_budget = len([p for p in actifs if p.ipc >= 0.95])
        dans_delais = len([p for p in actifs if p.ical >= 0.95])

        pourcentage_budget = (dans_budget / len(actifs) * 100) if actifs else 100
        pourcentage_delais = (dans_delais / len(actifs) * 100) if actifs else 100

        # Métriques de sécurité
        total_incidents = sum(p.incidents_declarables for p in tous_les_projets)
        total_heures = sum(p.heures_total for p in tous_les_projets)
        trir_portefeuille = (total_incidents * 200000 / total_heures) if total_heures > 0 else 0

        # Distribution de la santé
        vert = len([p for p in actifs if p.sante == StatutSante.VERT])
        jaune = len([p for p in actifs if p.sante == StatutSante.JAUNE])
        rouge = len([p for p in actifs if p.sante == StatutSante.ROUGE])

        # Tendances (comparaison avec la capture précédente si disponible)
        tendance_cout = "stable"
        tendance_calendrier = "stable"

        if self.captures:
            prec = self.captures[-1]
            if ipc_moyen > prec.get('avg_cpi', 1.0):
                tendance_cout = "en amélioration"
            elif ipc_moyen < prec.get('avg_cpi', 1.0):
                tendance_cout = "en déclin"

            if ical_moyen > prec.get('avg_spi', 1.0):
                tendance_calendrier = "en amélioration"
            elif ical_moyen < prec.get('avg_spi', 1.0):
                tendance_calendrier = "en déclin"

        return ResumePortefeuille(
            date_rapport=datetime.now(),
            total_projets=len(tous_les_projets),
            projets_actifs=len(actifs),
            valeur_contrat_total=total_contrat,
            budget_total=total_budget,
            cout_reel_total=total_reel,
            cout_previsionnel_total=total_previsionnel,
            ipc_moyen=ipc_moyen,
            ical_moyen=ical_moyen,
            pourcentage_dans_budget=pourcentage_budget,
            pourcentage_dans_delais=pourcentage_delais,
            trir_portefeuille=trir_portefeuille,
            total_incidents=total_incidents,
            nb_vert=vert,
            nb_jaune=jaune,
            nb_rouge=rouge,
            tendance_cout=tendance_cout,
            tendance_calendrier=tendance_calendrier
        )

    def comparer_projets(self, metrique: str) -> ComparaisonProjets:
        """Comparer les projets selon une métrique spécifique."""
        actifs = self.obtenir_projets_actifs()

        if not actifs:
            return None

        correspondance_metriques = {
            "cpi": lambda p: p.ipc,
            "spi": lambda p: p.ical,
            "percent_complete": lambda p: p.pourcentage_acheve,
            "cost_variance": lambda p: p.ecart_cout,
            "trir": lambda p: p.trir,
            "risk_score": lambda p: p.score_risque
        }

        if metrique not in correspondance_metriques:
            raise ValueError(f"Métrique inconnue : {metrique}")

        obteneur = correspondance_metriques[metrique]
        valeurs = {p.nom_projet: obteneur(p) for p in actifs}

        moyenne = statistics.mean(valeurs.values())

        # Meilleur/pire dépend de la métrique (un IPC élevé est bon, un TRIR bas est bon)
        if metrique in ["trir", "risk_score"]:
            meilleur = min(valeurs.items(), key=lambda x: x[1])
            pire = max(valeurs.items(), key=lambda x: x[1])
        else:
            meilleur = max(valeurs.items(), key=lambda x: x[1])
            pire = min(valeurs.items(), key=lambda x: x[1])

        return ComparaisonProjets(
            metrique=metrique,
            projets=valeurs,
            moyenne=moyenne,
            meilleur=meilleur,
            pire=pire
        )

    def obtenir_projets_a_risque(self) -> List[MetriquesProjet]:
        """Obtenir les projets qui nécessitent une attention."""
        return [p for p in self.obtenir_projets_actifs()
                if p.sante in [StatutSante.JAUNE, StatutSante.ROUGE]]

    def obtenir_principaux_risques(self, limite: int = 10) -> List[Dict]:
        """Obtenir les principaux risques dans l'ensemble du portefeuille."""
        risques = []

        for p in self.obtenir_projets_actifs():
            if p.score_risque > 0:
                risques.append({
                    "projet": p.nom_projet,
                    "score_risque": p.score_risque,
                    "risques_critiques": p.risques_critiques,
                    "ipc": p.ipc,
                    "ical": p.ical
                })

        return sorted(risques, key=lambda x: -x['score_risque'])[:limite]

    def prevoir_besoins_tresorerie(self, mois: int = 6) -> List[Dict]:
        """Prévoir les besoins de trésorerie dans l'ensemble du portefeuille."""
        previsions = []

        for mois_courant in range(1, mois + 1):
            date_mois = datetime.now() + timedelta(days=mois_courant * 30)

            depenses_mois = 0
            for p in self.obtenir_projets_actifs():
                # Projection linéaire simple basée sur le travail restant
                restant = p.cout_previsionnel - p.cout_reel
                mois_restants = max(1, (p.fin_previsionnelle - datetime.now()).days / 30)
                taux_mensuel = restant / mois_restants
                depenses_mois += taux_mensuel

            previsions.append({
                "mois": date_mois.strftime("%Y-%m"),
                "depenses_prevues": depenses_mois
            })

        return previsions

    def sauvegarder_capture(self):
        """Sauvegarder l'état actuel pour l'analyse des tendances."""
        resume = self.calculer_resume_portefeuille()
        if resume:
            self.captures.append({
                "date": datetime.now(),
                "avg_cpi": resume.ipc_moyen,
                "avg_spi": resume.ical_moyen,
                "on_budget_pct": resume.pourcentage_dans_budget,
                "on_schedule_pct": resume.pourcentage_dans_delais,
                "total_forecast": resume.cout_previsionnel_total
            })

    def generer_rapport(self) -> str:
        """Générer le rapport du tableau de bord du portefeuille."""
        resume = self.calculer_resume_portefeuille()

        if not resume:
            return "Aucun projet dans le portefeuille"

        lignes = [
            "# Tableau de bord du portefeuille",
            "",
            f"**Portefeuille :** {self.nom_portefeuille}",
            f"**Date du rapport :** {resume.date_rapport.strftime('%Y-%m-%d')}",
            "",
            "## Résumé exécutif",
            "",
            "| Métrique | Valeur |",
            "|--------|-------|",
            f"| Total des projets | {resume.total_projets} ({resume.projets_actifs} actifs) |",
            f"| Valeur totale des contrats | {resume.valeur_contrat_total:,.0f} € |",
            f"| Budget total | {resume.budget_total:,.0f} € |",
            f"| Coût réel à ce jour | {resume.cout_reel_total:,.0f} € |",
            f"| Prévision à l'achèvement | {resume.cout_previsionnel_total:,.0f} € |",
            f"| IPC moyen | {resume.ipc_moyen:.2f} |",
            f"| ICAL moyen | {resume.ical_moyen:.2f} |",
            f"| % dans le budget | {resume.pourcentage_dans_budget:.1f}% |",
            f"| % dans les délais | {resume.pourcentage_dans_delais:.1f}% |",
            f"| TRIR du portefeuille | {resume.trir_portefeuille:.1f} |",
            f"| Total des incidents | {resume.total_incidents} |",
            "",
            "## Répartition de la santé",
            "",
            f"- 🟢 Vert (sur la bonne voie) : {resume.nb_vert}",
            f"- 🟡 Jaune (à risque) : {resume.nb_jaune}",
            f"- 🔴 Rouge (critique) : {resume.nb_rouge}",
            "",
            "## Tendances",
            "",
            f"- **Tendance des coûts :** {resume.tendance_cout}",
            f"- **Tendance du calendrier :** {resume.tendance_calendrier}",
            "",
            "## Projets à risque",
            "",
        ]

        projets_a_risque = self.obtenir_projets_a_risque()
        if projets_a_risque:
            for p in projets_a_risque:
                lignes.append(f"- **{p.nom_projet}** - Santé : {p.sante.value}, IPC : {p.ipc:.2f}, ICAL : {p.ical:.2f}")
        else:
            lignes.append("Aucun projet n'est actuellement à risque.")

        lignes.extend([
            "",
            "## Principaux risques",
            "",
        ])

        principaux_risques = self.obtenir_principaux_risques()
        if principaux_risques:
            for risque in principaux_risques:
                lignes.append(f"- **{risque['projet']}** - Score de risque : {risque['score_risque']:.2f}, Risques critiques : {risque['risques_critiques']}")
        else:
            lignes.append("Aucun risque significatif identifié.")

        lignes.extend([
            "",
            "## Prévisions de trésorerie",
            "",
            "| Mois | Dépenses prévues |",
            "|------|------------------|",
        ])

        previsions = self.prevoir_besoins_tresorerie()
        for prev in previsions:
            lignes.append(f"| {prev['mois']} | {prev['projected_spend']:,.0f} € |")

        lignes.append("")
        lignes.append("---")
        lignes.append("*Rapport généré automatiquement*")

        return "\n".join(lignes)


# Exemple d'utilisation
if __name__ == "__main__":
    portefeuille = TableauBordPortefeuille("Projets de construction régionaux")

    # Importer les données de démonstration
    donnees_projets = [
        {
            "id": "CON-001",
            "name": "Développement du quartier Riverside",
            "status": "active",
            "contract_value": 50000000,
            "percent_complete": 45,
            "planned_start": datetime(2023, 6, 1),
            "planned_end": datetime(2025, 12, 31),
            "forecast_end": datetime(2026, 3, 15),
            "budget": 48000000,
            "actual_cost": 22000000,
            "forecast_cost": 51000000,
            "cpi": 0.92,
            "spi": 0.88,
            "incidents": 2,
            "total_hours": 120000,
            "risk_score": 6.5,
            "critical_risks": 2
        },
        {
            "id": "CON-002",
            "name": "Pont de la baie Nord",
            "status": "active",
            "contract_value": 80000000,
            "percent_complete": 60,
            "planned_start": datetime(2022, 1, 1),
            "planned_end": datetime(2024, 6, 30),
            "actual_start": datetime(2022, 1, 15),
            "forecast_end": datetime(2024, 8, 15),
            "budget": 75000000,
            "actual_cost": 44000000,
            "forecast_cost": 78000000,
            "cpi": 0.97,
            "spi": 0.95,
            "incidents": 1,
            "total_hours": 200000,
            "risk_score": 4.2,
            "critical_risks": 0
        },
        {
            "id": "CON-003",
            "name": "Tunnel du centre-ville",
            "status": "active",
            "contract_value": 120000000,
            "percent_complete": 30,
            "planned_start": datetime(2024, 1, 1),
            "planned_end": datetime(2026, 12, 31),
            "actual_start": datetime(2024, 1, 15),
            "forecast_end": datetime(2027, 6, 30),
            "budget": 115000000,
            "actual_cost": 40000000,
            "forecast_cost": 125000000,
            "cpi": 0.85,
            "spi": 0.82,
            "incidents": 3,
            "total_hours": 150000,
            "risk_score": 8.9,
            "critical_risks": 4
        }
    ]

    portefeuille.importer_projets(donnees_projets)

    # Générer le rapport
    rapport = portefeuille.generer_rapport()
    print(rapport)

API de référence

Principales classes

ClasseDescription
StatutProjetÉnumération des statuts de projet : planification, actif, en suspens, terminé, annulé
StatutSanteÉnumération de la santé du projet : vert (bon), jaune (à risque), rouge (critique), gris (inactif)
MetriquesProjetMétriques détaillées d'un projet individuel, y compris les coûts, le calendrier, la sécurité, la qualité et les risques
ResumePortefeuilleRésumé du portefeuille calculé avec KPI agrégés
ComparaisonProjetsRésultats de la comparaison entre projets pour une métrique spécifique
TableauBordPortefeuilleAnalyse principale du portefeuille multi-projets avec tous les calculs et la génération de rapports

Principales méthodes

MéthodeRetourneDescription
ajouter_projet()NoneAjouter ou mettre à jour un projet dans le portefeuille
importer_projets()intImporter plusieurs projets à partir de dictionnaires de données
calculer_resume_portefeuille()ResumePortefeuilleCalculer les métriques de résumé du portefeuille, y compris les moyennes pondérées
comparer_projets(metrique)ComparaisonProjetsComparer les projets par métrique spécifique avec les résultats les meilleurs/pires
obtenir_projets_a_risque()List[MetriquesProjet]Obtenir les projets avec une santé jaune ou rouge
obtenir_principaux_risques(limite)List[Dict]Obtenir les N premiers risques dans l'ensemble du portefeuille
prevoir_besoins_tresorerie(mois)List[Dict]Prévoir les besoins de trésorerie mensuels pour les X prochains mois
generer_rapport()strGénérer un rapport complet au format markdown du tableau de bord

Métriques de comparaison

  • ipc - Indice de performance des coûts (supérieur est meilleur)
  • ical - Indice de performance du calendrier (supérieur est meilleur)
  • pourcentage_acheve - Pourcentage d'avancement
  • ecart_cout - Écart de coût (budget - réel)
  • trir - Taux d'incidents enregistrables total (inférieur est meilleur)
  • score_risque - Score de risque global (inférieur est meilleur)

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

majiayu000/claude-skill-registry

Builds, edit or validate Agent Skill through conversational discovery. Use when the user requests to "Create an Agent", "Optimize an Agent" or "Edit an Agent".

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD agents while maintaining compliance

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Edit existing BMAD modules while maintaining coherence

majiayu000/claude-skill-registry

Analyzes current state and user query to answer BMad questions or recommend the next workflow or agent. Use when user says what should I do next, what do I do now, or asks a question about BMad

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Build AI agents with Google ADK Python (Agent Development Kit). Use for multi-agent systems, workflow agents (sequential/parallel/loop), Vertex AI deployment, tool integration, human-in-the-loop.

majiayu000/claude-skill-registry

Portfolio allocation and rebalancing optimizer. Manages asset allocation across stocks/cash/bonds, performs periodic rebalancing, and ensures diversification according to market regime and risk tolerance.

majiayu000/claude-skill-registry

Create a hilarious and ultra-realistic video of an anthropomorphic animal acting like a human vlogger in a real-world setting.

majiayu000/claude-skill-registry

Speech-to-text transcription and translation via OpenAI Audio API -- models, response formats, timestamps, prompting, streaming, chunking, and diarization

majiayu000/claude-skill-registry

BlockRun works with Claude Code and Google Antigravity.

majiayu000/claude-skill-registry

This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.

majiayu000/claude-skill-registry

小省导购员数字人带货版即梦视频提示词生成系统,基于四大智能体协同(提示词生成师、质量管控师、知识库运维师、跨环节适配师),按照"主体+运动+场景+(镜头语言+光影+氛围)"公式输出中英文双版提示词,适配5s短视频。确保人物一致性、视觉连贯性、情绪连贯性,支持知识库智能复用和跨工具适配(Suno音乐、AI绘画),为数字人带货视频提供高质量提示词生成服务。

majiayu000/claude-skill-registry

Upload and manage files using Google Gemini File API via scripts/. Use for uploading images, audio, video, PDFs, and other files for use with Gemini models. Supports file upload, status checking, and file management. Triggers on "upload file", "file API", "upload image", "upload PDF", "upload video", "file management".

majiayu000/claude-skill-registry

CRITICAL: Use for MolyKit AI chat toolkit. Triggers on: BotClient, OpenAI, SSE streaming, AI chat, molykit, PlatformSend, spawn(), ThreadToken, cross-platform async, Chat widget, Messages, PromptInput, Avatar, LLM

majiayu000/claude-skill-registry

AI and machine learning workflow covering LLM application development, RAG implementation, agent architecture, ML pipelines, and AI-powered features.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Analyze images/audio/video with Gemini API (better vision than Claude). Generate images (Imagen 4), videos (Veo 3). Use for vision analysis, transcription, OCR, design extraction, multimodal AI.

majiayu000/claude-skill-registry

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés