Communitygithub.com

Compétence MolyKit

CRITIQUE : Utiliser pour la boîte à outils de chat IA MolyKit. Se déclenche sur : BotClient, OpenAI, streaming SSE, chat IA, molykit, PlatformSend, spawn(), ThreadToken, asynchrone multiplateforme, widget de chat, Messages, PromptInput, Avatar, LLM.

Qu'est-ce que Compétence MolyKit ?

Cette compétence fournit les meilleures pratiques et schémas architecturaux pour construire des interfaces de chat IA avec Makepad en utilisant MolyKit, une boîte à outils pour applications de chat IA multiplateformes. Elle prend en charge l'intégration d'OpenAI et d'autres API LLM, l'asynchrone multiplateforme pour le natif et WASM, et la création de widgets de chat (messages, invites, avatars). La compétence couvre des schémas asynchrones critiques comme `PlatformSend` (envoi uniquement sur natif), `spawn()` (lancement agnostique), `AbortOnDropHandle` (annulation de tâche), et `ThreadToken` (valeurs non-Send sur WASM). Elle documente également le trait `BotClient` pour l'intégration des fournisseurs d'IA, le wrapper `BotContext` pour un accès synchronisé à l'interface utilisateur, le widget `Slot` pour la substitution de contenu à l'exécution, les widgets `Avatar` et `PromptInput`, et le streaming SSE pour les réponses en temps réel. En suivant ces schémas, les développeurs peuvent écrire du code de chat IA qui fonctionne de manière transparente sur les plateformes natives et WASM sans nécessiter de modifications spécifiques à chaque plateforme.

Compatible avec✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/majiayu000/claude-skill-registry/tree/HEAD/skills/ai-llm/molykit-galacticvraj-vraj-portfolio

Demander à votre IA préférée

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

Documentation

Que fait Compétence MolyKit ?

Meilleures pratiques pour construire des interfaces de chat IA avec Makepad en utilisant MolyKit - une boîte à outils pour applications de chat IA multiplateformes.

Code source : /Users/zhangalex/Work/Projects/FW/robius/moly/moly-kit

Quand l'utiliser

Utilisez cette compétence lorsque :

  • Vous construisez des interfaces de chat IA avec Makepad
  • Vous intégrez OpenAI ou d'autres API LLM
  • Vous implémentez l'asynchrone multiplateforme pour le natif et WASM
  • Vous créez des widgets de chat (messages, invites, avatars)
  • Vous gérez les réponses en streaming SSE
  • Mots-clés : molykit, moly-kit, chat IA, client bot, openai makepad, widget de chat, streaming sse

Aperçu

MolyKit fournit :

  • Utilitaires asynchrones multiplateformes (PlatformSend, spawn(), ThreadToken)
  • Widgets de chat prêts à l'emploi (Chat, Messages, PromptInput, Avatar)
  • Trait BotClient pour l'intégration de fournisseurs d'IA
  • Client compatible OpenAI avec streaming SSE
  • Types de protocole pour les messages, bots et appels d'outils
  • Support MCP (Model Context Protocol)

Schémas asynchrones multiplateformes

PlatformSend - Envoi uniquement sur natif

/// Implique Send uniquement sur les plateformes natives, pas sur WASM
/// - Sur natif : implémenté par les types qui implémentent Send
/// - Sur WASM : implémenté par TOUS les types
pub trait PlatformSend: PlatformSendInner {}

/// Type de future boxé pour utilisation multiplateforme
pub type BoxPlatformSendFuture<'a, T> = Pin<Box<dyn PlatformSendFuture<Output = T> + 'a>>;

/// Type de stream boxé pour utilisation multiplateforme
pub type BoxPlatformSendStream<'a, T> = Pin<Box<dyn PlatformSendStream<Item = T> + 'a>>;

Lancement agnostique

/// Exécute une future indépendamment
/// - Utilise tokio sur natif (nécessite Send)
/// - Utilise wasm-bindgen-futures sur WASM (Send non requis)
pub fn spawn(fut: impl PlatformSendFuture<Output = ()> + 'static);

// Utilisation
spawn(async move {
    let result = fetch_data().await;
    Cx::post_action(DataReady(result));
    SignalToUI::set_ui_signal();
});

Annulation de tâche avec AbortOnDropHandle

/// Handle qui annule sa future lorsqu'il est libéré
pub struct AbortOnDropHandle(AbortHandle);

// Utilisation - tâche annulée lorsque le widget est libéré
#[rust]
task_handle: Option<AbortOnDropHandle>,

fn start_task(&mut self) {
    let (future, handle) = abort_on_drop(async move {
        // travail asynchrone...
    });
    self.task_handle = Some(handle);
    spawn(async move { let _ = future.await; });
}

ThreadToken pour les types non-Send sur WASM

/// Stocke une valeur non-Send dans un stockage local de thread, accès via token
pub struct ThreadToken<T: 'static>;

impl<T> ThreadToken<T> {
    pub fn new(value: T) -> Self;
    pub fn peek<R>(&self, f: impl FnOnce(&T) -> R) -> R;
    pub fn peek_mut<R>(&self, f: impl FnOnce(&mut T) -> R) -> R;
}

// Utilisation - envelopper un type non-Send pour une utilisation à travers des limites Send
let token = ThreadToken::new(non_send_value);
spawn(async move {
    token.peek(|value| {
        // utiliser value...
    });
});

Trait BotClient

Implémentation de l'intégration de fournisseurs d'IA

pub trait BotClient: Send {
    /// Envoyer un message avec réponse en streaming
    fn send(
        &mut self,
        bot_id: &BotId,
        messages: &[Message],
        tools: &[Tool],
    ) -> BoxPlatformSendStream<'static, ClientResult<MessageContent>>;

    /// Obtenir les bots/modèles disponibles
    fn bots(&self) -> BoxPlatformSendFuture<'static, ClientResult<Vec<Bot>>>;

    /// Clone pour passer
    fn clone_box(&self) -> Box<dyn BotClient>;
}

// Utilisation
let client = OpenAIClient::new("https://api.openai.com/v1".into());
client.set_key("sk-...")?;
let context = BotContext::from(client);

BotContext - Wrapper partageable

/// Wrapper partageable avec des bots chargés pour un accès UI synchrone
pub struct BotContext(Arc<Mutex<InnerBotContext>>);

impl BotContext {
    pub fn load(&mut self) -> BoxPlatformSendFuture<ClientResult<()>>;
    pub fn bots(&self) -> Vec<Bot>;
    pub fn get_bot(&self, id: &BotId) -> Option<Bot>;
    pub fn client(&self) -> Box<dyn BotClient>;
}

// Utilisation
let mut context = BotContext::from(client);
spawn(async move {
    if let Err(errors) = context.load().await.into_result() {
        // gérer les erreurs
    }
    Cx::post_action(BotsLoaded);
});

Types de protocole

Structure du message

pub struct Message {
    pub from: EntityId,         // User, System, Bot(BotId), App
    pub metadata: MessageMetadata,
    pub content: MessageContent,
}

pub struct MessageContent {
    pub text: String,           // Contenu principal (markdown)
    pub reasoning: String,      // Raisonnement/réflexion de l'IA
    pub citations: Vec<String>, // URLs des sources
    pub attachments: Vec<Attachment>,
    pub tool_calls: Vec<ToolCall>,
    pub tool_results: Vec<ToolResult>,
}

pub struct MessageMetadata {
    pub is_writing: bool,       // En cours de streaming
    pub created_at: DateTime<Utc>,
}

Identification du bot

/// ID de bot globalement unique : <len>;<id>@<provider>
pub struct BotId(Arc<str>);

impl BotId {
    pub fn new(id: &str, provider: &str) -> Self;
    pub fn id(&self) -> &str;       // ID local au fournisseur
    pub fn provider(&self) -> &str; // Domaine du fournisseur
}

// Exemple : BotId::new("gpt-4", "api.openai.com")
// -> "5;[email protected]"

Schémas de widgets

Widget Slot - Remplacement de contenu à l'exécution

live_design! {
    pub Slot = {{Slot}} {
        width: Fill, height: Fit,
        slot = <View> {}  // contenu par défaut
    }
}

// Utilisation - remplacer le contenu à l'exécution
let mut slot = widget.slot(id!(content));
if let Some(custom) = client.content_widget(cx, ...) {
    slot.replace(custom);
} else {
    slot.restore();  // retour au défaut
    slot.default().as_standard_message_content().set_content(cx, &content);
}

Widget Avatar - Bascule Texte/Image

live_design! {
    pub Avatar = {{Avatar}} <View> {
        grapheme = <RoundedView> {
            visible: false,
            label = <Label> { text: "P" }
        }
        dependency = <RoundedView> {
            visible: false,
            image = <Image> {}
        }
    }
}

impl Widget for Avatar {
    fn draw_walk(&mut self, cx: &mut Cx2d, ...) -> DrawStep {
        if let Some(avatar) = &self.avatar {
            match avatar {
                Picture::Grapheme(g) => {
                    self.view(id!(grapheme)).set_visible(cx, true);
                    self.view(id!(dependency)).set_visible(cx, false);
                    self.label(id!(label)).set_text(cx, &g);
                }
                Picture::Dependency(d) => {
                    self.view(id!(dependency)).set_visible(cx, true);
                    self.view(id!(grapheme)).set_visible(cx, false);
                    self.image(id!(image)).load_image_dep_by_path(cx, d.as_str());
                }
            }
        }
        self.deref.draw_walk(cx, scope, walk)
    }
}

Widget PromptInput

#[derive(Live, Widget)]
pub struct PromptInput {
    #[deref] deref: CommandTextInput,
    #[live] pub send_icon: LiveValue,
    #[live] pub stop_icon: LiveValue,
    #[rust] pub task: Task,           // Envoyer ou Arrêter
    #[rust] pub interactivity: Interactivity,
}

impl PromptInput {
    pub fn submitted(&self, actions: &Actions) -> bool;
    pub fn reset(&mut self, cx: &mut Cx);
    pub fn set_send(&mut self);
    pub fn set_stop(&mut self);
    pub fn enable(&mut self);
    pub fn disable(&mut self);
}

Widget Messages - Vue de conversation

#[derive(Live, Widget)]
pub struct Messages {
    #[deref] deref: View,
    #[rust] pub messages: Vec<Message>,
    #[rust] pub bot_context: Option<BotContext>,
}

impl Messages {
    pub fn set_messages(&mut self, messages: Vec<Message>, scroll_to_bottom: bool);
    pub fn scroll_to_bottom(&mut self, cx: &mut Cx, triggered_by_stream: bool);
    pub fn is_at_bottom(&self) -> bool;
}

Schéma UiRunner pour Async-vers-UI

impl Widget for PromptInput {
    fn handle_event(&mut self, cx: &mut Cx, event: &Event, scope: &mut Scope) {
        self.deref.handle_event(cx, event, scope);
        self.ui_runner().handle(cx, event, scope, self);

        if self.button(id!(attach)).clicked(event.actions()) {
            let ui = self.ui_runner();
            Attachment::pick_multiple(move |result| match result {
                Ok(attachments) => {
                    ui.defer_with_redraw(move |me, cx, _| {
                        me.attachment_list_ref().write().attachments.extend(attachments);
                    });
                }
                Err(_) => {}
            });
        }
    }
}

Streaming SSE

/// Analyser un flux d'octets SSE en flux de messages
pub fn parse_sse<S, B, E>(s: S) -> impl Stream<Item = Result<String, E>>
where
    S: Stream<Item = Result<B, E>>,
    B: AsRef<[u8]>,
{
    // Diviser sur "\n\n", extraire le contenu "data:"
    // Filtrer les commentaires et les messages [DONE]
}

// Utilisation dans BotClient::send
fn send(&mut self, ...) -> BoxPlatformSendStream<...> {
    let stream = stream! {
        let response = client.post(url).send().await?;
        let events = parse_sse(response.bytes_stream());

        for await event in events {
            let completion: Completion = serde_json::from_str(&event)?;
            content.text.push_str(&completion.delta.content);
            yield ClientResult::new_ok(content.clone());
        }
    };
    Box::pin(stream)
}

Meilleures pratiques

  1. Utilisez PlatformSend pour le multiplateforme : Même code fonctionne sur natif et WASM
  2. Utilisez spawn() pas tokio::spawn : Lancement de tâche agnostique
  3. Utilisez AbortOnDropHandle : Annulez les tâches lorsque le widget est libéré
  4. Utilisez ThreadToken pour non-Send sur WASM : Stockage local de thread avec accès par token
  5. Utilisez Slot pour le contenu personnalisé : Permettez à BotClient de fournir des widgets personnalisés
  6. Utilisez le modèle read()/write() : Accès d'emprunt sécurisé via WidgetRef
  7. Utilisez UiRunner::defer_with_redraw : Mettez à jour le widget depuis un contexte asynchrone
  8. Gérez le succès partiel de ClientResult : Peut avoir une valeur ET des erreurs

Fichiers de référence

  • llms.txt - Référence complète de l'API MolyKit

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

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

Conduct domain and industry research. Use when the user says "lets create a research report on [domain or industry]

majiayu000/claude-skill-registry

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

Skills associés