Tag Archives: docs

Jonathan Bossenger 2:06 pm on 11 July 2025
Tags: , docs, ,   

AI Chat Summary – 10 July 2025

Location: #core-ai Slack Channel

Agenda: No formal agenda

This summary covers the key discussion points from the last bi-weekly AI chat in the Make WordPress SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.. This week, the discussion focused on the PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/preface.php. AI Client SDK.

1. PHP AI Client SDK – Project Status and Discussion

2. Defining User Audiences: Extenders vs. Implementors

  • @jason_the_adams highlighted a distinction regarding the SDK’s users and its impact on design:
    • Extenders: Highly technical users who will extend the client by adding providers and models. The APIs for this group will be technical to ensure well-defined integrations.
    • Implementors: Developers who want to use the client for features like generating alt text without needing deep knowledge of AI models. The goal for this APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. surface is ease of use and simplicity, minimizing the need to understand underlying AI complexities.
  • @flixos90 clarified that the implementor API would still allow granular customization, but such advanced options would not be mandatory.
  • @jeffpaul also noted that some users might operate at the intersection of both roles. 
  • The overall idea to “make the easy things easy, and the hard things possible” was reiterated as a guiding principle. 
  • The distinction between the two API surfaces is outlined in the SDK’s architecture requirements.

3. Fluent API vs. Traditional Method Calls

A significant part of the discussion revolved around the proposed shift to a Fluent API for the implementor surface, contrasting it with the traditional method call pattern inspired by the Vercel AI SDK.

  • Fluent API Advocates: @jason_the_adams and @flixos90 provided code examples demonstrating the cleaner, more declarative, and readable nature of a Fluent API (e.g., `Ai::prompt(…)->generateImage();`).
    • They agreed it would reduce errors and typos associated with nested arrays in traditional approaches. 
    • @borkweb later echoed strong support, noting its discoverability in IDEs.
  • Proposed Approach: @flixos90 suggested updating the proposed architecture to prioritize the Fluent API while allowing the traditional method-based API as a wrapper.
    • @jason_the_adams advised starting with the Fluent API first, as it’s easier to add the traditional API later than to remove it.

4. Token Usage and Response Metadata

  • @dunhakdis raised the importance of standardizing token-usage data exposure, suggesting that the SDK should consistently provide metadata regardless of the AI provider. 
  • @jason_the_adams elaborated on three types of prompt returns:
    • Result object: Contains comprehensive data and is synchronously returned.
    • Operation object: For asynchronous, long-running requests.
    • Ease-of-use method: Directly retrieves the intended value from the Result object.

5. Open Floor: Researching Triage Opportunities

  • @karmatosed inquired about collaborating on research into AI systems for easing CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress./GutenbergGutenberg The Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc. https://wordpress.org/gutenberg/ ticket triage. 
  • @flixos90 suggested using GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ discussions for these asynchronous conversations, a proposal @karmatosed welcomed.

Props to @jeffpaul for review.

#core-ai, #docs, #meeting, #summary

Tammie Lister 9:40 pm on 26 June 2025
Tags: , docs, ,   

AI Chat Summary – 26 June 2025

Location: #core-ai Slack Channel

Agenda: AI Chat Agenda – 26 June 2025

Project Administration

  • @isotropic outlined GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/ project setup to coordinate WordPress AI efforts.
  • Introduced the new php-ai-client GitHub repository.
  • Plans for related repos for other “building blockBlock Block is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.” focuses such as MCP and unified tool registry.

PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/preface.php. AI Client SDK

TL;DR: The php-ai-client SDK will be a vendor-neutral PHP foundation, extended by a WordPress-specific layer.

  • @flixos90 described the php-ai-client as:
    • A platform-agnostic PHP SDK for connecting to AI models.
    • Designed to be extensibleExtensible This is the ability to add additional functionality to the code. Plugins extend the WordPress core software. and vendor-neutral.
  • @isotropic noted a WordPress-specific layer would build on this foundation.
  • @dan2k3k4 mentioned external contributions from amazee.ai aiming to integrate AI provider support.

Provider Inclusion, Structure, and Extensibility

TL;DR: Provider support will be modular and extensible, starting with initially identified vendors. Proxy architecture and advanced features like cost management are key priorities.

  • @flixos90 introduced provider inclusion strategies:
    • No providers bundled (all external).
    • All providers bundled (with strict criteria).
    • Selective bundling based on clear criteria.
    • Highlighted difficulty of setting unbiased, verifiable inclusion rules.
    • Suggested a stakeholder approval process for new providers.
    • Recommended starting with “big 3” providers (OpenAI, Anthropic, Google) in separate branches.
    • Preferred eventual migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. of providers to separate repositories.
  • @isotropic favored:
    • Bundling widely adopted providers with stable APIs.
    • Documenting unofficial provider modules with potential promotion based on usage.
  • @jason_the_adams and others discussed monorepo versus multiple repositories for managing provider modules.
  • Proxy provider and hosting integration emphasized by @jason_the_adams and @isotropic, with @flixos90 adding SDK architectural support for proxying.
  • Advanced feature support discussed by@zhendershot and @flixos90 including cost management, model routing handled at WordPress-specific layer with extensibility.
  • @jeffpaul referenced WordPress’s OEmbed provider process as a precedent: WordPress Core Trac Ticket #58840
  • Roadmap outlined for integrating AI features into WordPress with no near-term coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. merge planned.

Proxy Providers and Hosting

TL;DR: Hosting providers may bundle AI capabilities via proxies. Integration with hosts like amazee.ai is underway to drive adoption.

  • @jason_the_adams detailed proxy use cases where hosts bundle AI credits and monitor usage.
  • @isotropic and @flixos90 discussed:
    • Host registration of providers versus proxying.
    • SDK’s capability to route requests via proxy endpoints.
  • @dan2k3k4 shared amazee.ai’s intent to be a provider and collaboration efforts with WordPress agencies.
  • @jason_the_adams emphasized hosting adoption is key for WordPress AI success.

Repository Architecture

TL;DR: Monorepo favored for adaptability, but some prefer modular repos for clearer issue and project management.

  • @jason_the_adams advocated for monorepo structure for flexibility and version management.
  • @karmatosed preferred separate repositories for better project and issue management.
  • @isotropic supported monorepo approach for adaptability and hosting flexibility.

Roadmap and Core Integration

TL;DR: Project will roll out as a Canonical/Feature PluginFeature Plugin A plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins. first, with no immediate plans to merge into WordPress core.

  • @sirlouen asked whether the project aligns more with a Feature Plugin than Core at this stage.
  • @flixos90 and @isotropic agreed:
    • Phased approach with separate packages.
    • No immediate core merge planned.
    • WordPress-specific code expected to ship initially as a Feature Plugin.

REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/. Handling

TL;DR: REST API specs may live in the SDK repo, but broader design and GraphQL parity are being considered. Further discussion will continue on GitHub.

  • @jason_the_adams expressed enthusiasm for REST API specification residing in the php-ai-client repo: REQUIREMENTS.md in php-ai-client
  • @flixos90 agreed:
    • It’s a good idea worthy of further discussion.
    • Leans pragmatic but sees broader specification’s scalability benefits.
    • Encouraged ongoing discussions in php-ai-client GitHub repository
  • @justlevine hopes:
    • REST handling remains outside core SDK.
    • WPGraphQL aims to offer APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. parity.
  • @jason_the_adams committed to raising topics as GitHub issues.

Props to @jeffpaul for review.

#core-ai, #docs, #meeting, #summary

Tammie Lister 10:29 pm on 13 June 2025
Tags: , docs, ,   

AI Chat Summary – 12 June 2025

Location: #core-ai Slack Channel

Theme: Next Steps After WordCampWordCamp WordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Europe + Building Blocks for AI in WordPress

Meeting Overview

The AI Team discussed strategic next steps following WordCamp Europe and recent Hallway Hangouts. The focus was on identifying foundational building blocks to support AI development in WordPress, while balancing innovation with long-term maintainability and backward compatibility.

Foundational Strategy & Technical Architecture

CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Building Blocks for AI in WordPress

TLDR: Foundational technical architecture to enable flexible AI development.

The AI Team outlined a three-part “Building Blocks” strategy for AI in WordPress:

  1. Provider-Agnostic LLM Client Abstraction – A shared PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/preface.php. abstraction layer for interacting with different LLM providers.
  2. Tool & Resource Definition / Registration – A system to register site features (“abilities”) that LLMs can understand and interact with.
  3. Integration Bridges (e.g., MCP) – Support for protocols like MCP to connect WordPress to external AI tools and ecosystems.

A showcase pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party is also planned to demonstrate these concepts working together and help developers build on top of the stack.

Shared LLM Abstraction Layer

TLDR: A PHP package to enable provider-agnostic LLM support across plugins and frameworks.

  • PHP lacks a shared LLM abstraction; most WP plugins today hard-code provider-specific integrations.
  • @flixos90 shared ai-services, a plugin that abstracts LLM provider access, with plans to extract it into a PHP-agnostic package.
  • @isotropic confirmed similar needs exist in Laravel and other PHP projects.
  • @swissspidy  noted this as a leadership opportunity for WordPress within the PHP ecosystem.
  • @schnitzel86 (Drupal) expressed interest in collaborating on shared tooling.
  • @johnbillion added that Laravel/Symfony contributors likely face the same challenges.

Tool & Resource Registry + MCP Integration

TLDR: Defining features that AI can understand and interact with, using standards like MCP.

  • MCP (Model Context Protocol) allows LLMs to connect with tools across software platforms.
  • Tools like data fetching, publishing, and media access can be exposed via MCP or standalone.
  • @isotropic noted MCP is maturing rapidly and may signal converging best practices around tools/resources.
  • @flixos90 suggested MCP integration could support both external use (e.g. desktop clients) and internal use (e.g. admin-side agents).
  • @swissspidy highlighted WordPress media handling as an ideal “resource” use case.

AI Feature Registration and Cross-System Integration

TLDR: Inspired by the Feature APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.: registering “abilities” LLMs can use via protocols like MCP.

  • Inspired by the Feature API, the team envisions a system for registering “abilities” that LLMs can query.
  • Enables workflows from simple button-triggered AI actions to multi-tool agents.
  • Protocols like MCP act as bridges, exposing these capabilities to other systems or importing tools from platforms like GitHubGitHub GitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged be the repository owner. https://github.com/.
  • Early prototypes include AI-Command and WordPress MCP.

Sustainable Development and Tech Debt Strategy

TLDR: Avoiding early lock-in by using canonical plugins and adapter-based architecture.

  • AI tech is evolving rapidly; WordPress must guard against locking into unstable patterns.
  • The team favors:
    • Canonical plugins as the main innovation space.
    • WordPress-first adapters to shield internal APIs from volatile protocols.
    • Keeping most work Core-adjacent unless clearly stable.
  • @isotropic emphasized an “adapter-style” approach.
  • @flixos90 added that AI is still early and most tooling doesn’t belong in Core yet.
  • @jeffpaul supported this modular approach as a way to iterate quickly and responsibly.

Implementation Focus: Use Cases & Experiments

AI-Powered Triage for Plugins, Themes, and Tickets

TLDR: Exploring how AI can assist with reviews and moderation across WordPress.orgWordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/.

  • Triage (plugin/theme/ticket review) is a prime use case for AI.
  • @karmatosed: wants to apply AI to triage but with “just enough structure.”
  • Unattributed: many OSS projects are already experimenting here.
  • @isotropic: pointed to dosu.dev as a model.
  • @SirLouen: cautioned against skipping over simple automation.
  • @flixos90 noted traditional tools may be more effective for well-defined tasks.
  • @justlevine: urged reinforcing static analysis and quality tooling first (e.g. PHPStan).

AI for Documentation and Contributor Support

TLDR: Generating user-facing docs with LLMs and streamlining onboarding materials.

  • @estelaris is testing LLMs (e.g. ChatGPT) to generate user-facing docs using the WordPress glossary and style guide.
  • Current content is inaccurate or off-tone, but long-term goal is full automation from feature videos or releases.
  • @jeffpaul confirmed AI Team support for helping Make teams adopt AI — especially #docs.

RAG and Vector Support in WordPress

TLDR: Future consideration for retrieval-augmented generation and vector-based search as MySQLMySQL MySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/. evolves.

  • @pbiron: asked about support for RAG workflows and vector-based search.
    • Noted MySQL 9’s experimental vector data types.
  • @isotropic: shared past prototype wpvdb.
    • Suggested future support for vector/hybrid search in WP_Query or REST APIREST API The REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”) https://developer.wordpress.org/rest-api/..
  • @jeffpaul: emphasized exploring early so the community is informed when it’s time to act.

Governance, Culture & Infrastructure

Culture of Collaboration, Governance, and Experimentation

TLDR: Creating a space for decentralized innovation, sharing results, and team autonomy.

  • @isotropic: proposed a collaborative “opportunity areas” list for AI across teams.
  • @isotropic: proposed publishing it on Make/Core to help teams self-organize vs needing AI team ownership.
  • @estelaris: encouraged publishing experiments and results on Make blogs.
  • @flixos90: urged matching the right tool to the job — not every problem needs an LLM.
  • @justlevine: emphasized we need stronger foundations before layering AI on top.

Technical Planning: GitHub Strategy and Infra

TLDR: Deciding between monorepo vs multi-repo setups to support scalable collaboration.

  • Discussed whether to use a monorepo or individual GitHub repos.
  • This will impact collaboration, package structure, and release processes.
  • Team will aim for clarity by mid-next week via async discussion.

Philosophy: Canonical First, Core When Ready

TLDR: A clear development ethos: iterate fast in plugins, stabilize before touching Core.

WordPress’s long-term success with AI depends on:

  • Starting with canonical plugins and packages.
  • Building adapter-style architecture to insulate Core from churn.
  • Encouraging a culture of open experimentation, documentation, and shared learning.
  • Letting the best ideas bubble up through real-world usage and community support.

Open Next Steps & To-Dos

  • Decide GitHub Repo Structure
    Async discussion this week to determine whether to use a monorepo or split repositories for AI-related work.
    Target: Clarity by mid-next week (June 19–20).
  • Extract ai-services into Shared PHP Package
    @flixos90 shared an early version. Action needed to extract and formalize this for community use.
  • Prototype Showcase Plugin
    A new plugin is planned to demonstrate how LLM client abstraction, tool registration, and MCP integration work together. Contributors welcome.
  • Document AI Opportunity Areas
    @isotropic suggested publishing a public list of cross-team AI opportunities (e.g. Docs, Design, Triage).
    Goal: Help Make teams self-organize without AI team bottlenecks.
  • Encourage Make Team Experiments
    Encourage publishing early use cases and learnings (e.g., Docs experiments from @estelaris) on Make/Core or respective team blogs.
  • Explore RAG + Vector Support Path
    Initial interest flagged around integrating MySQL 9 vector types and reviving the wpvdb prototype. More research needed.
  • Continue Triaging AI in Contributor Workflows
    Discussion to continue on how to balance static analysis tools (e.g., PHPStan) with LLM-based systems like dosu.dev.

Props to @jeffpaul for review.

#core-ai, #meeting, #summary