Add Meshery project ideas for LFX 2026 Term 2

programs/lfx-mentorship/2026/02-Jun-Aug/project_ideas.md

@@ -223,3 +223,104 @@
   - Gourish Biradar (email: biradar.gourish@gmail.com, github: gourishkb) , Prabhu Navali (email: prabhu@avesha.io, github: pnavali), Rahul Kumar (email: rahulparida933@gmail.com, github: Rahul-D78)
 - Upstream Issue(s):
   - https://github.com/kubeslice/kubeslice-controller/issues/306
+
+### Meshery
+
+#### Relationships and Solutions Architecture of Cloud Native Deployments
+
+CNCF - Meshery: Relationships and Solutions Architecture of Cloud Native Deployments (2026 Term 2)
+
+- Description: Meshery Models are declarative representations of infrastructure and applications. Within these models, Relationships define how different Components (e.g., Kubernetes resources, Cloud services) interact and depend on each other. These relationships are crucial for visualizing, understanding, and managing complex cloud native systems. This project focuses on expanding Meshery Relationships across a wide range of technologies, including Kubernetes and major cloud providers, to better model their interactions and improve user insights. There is a growing need to accurately model these relationships to provide better insights and control over deployments.
+  The next phase focuses on Cloud Solution Architecture through workload design by creating and publishing Meshery designs that use the newly developed relationships to represent real-world deployments. These designs will be turned into structured tutorials with hands-on labs using Meshery Playground, offering step-by-step guidance and interactive learning. All content will be reviewed by maintainers and published in Meshery’s official documentation
+- Responsibilities:
+  - Research and Analyze Technologies: Dive deep into various cloud-native technologies (e.g., different compute services, databases, messaging systems, network services, etc.) to understand their components and how they interconnect.
+  - Develop Relationship Definitions: Create and contribute relationship definitions, typically in JSON or YAML format, to the Meshery models.
+  - Model Inter-Technology Interactions: Focus particularly on defining relationships between components from different technologies (e.g., how a Kubernetes deployment relates to an AWS RDS instance, or how a Linkerd service interacts with a Prometheus monitoring component).
+  - Document New Relationships: Clearly document the newly defined relationships, their purpose, and how they are represented within Meshery designs, contributing to the official Meshery documentation.
+  - Create and publish designs that use newly developed relationships.
+  - Create and publish hands-on tutorials using Meshery Playground, featuring step-by-step guides and interactive labs that enable learners to apply concepts without the hassle of any configuration.
+- Expected Outcome:
+  - A multitude of new intra- and inter-service relationships defined across AWS, Azure, and GCP.
+  - Creation and publishing of real-world workload designs that represent cloud solution architectures using the newly defined relationships.
+  - Tutorials reviewed by various project maintainers and then published in guides/tutorials.
+  - Policy Contribution: For advanced interns, there may be opportunities to contribute to the Rego policies that evaluate and enforce these relationships.
+- Recommended Skills: DevOps, systems administration, and solutions architecture, experience with Kubernetes and cloud platforms (AWS, Azure, GCP), proficiency in Markdown and technical writing, familiarity with cloud-native tools.
+- Mentor(s):
+  - Sangram Rath (@sangramrath, sangram.rath@gmail.com)
+  - Lee Calcote (@leecalcote, lee.calcote@gmail.com)
+- Upstream Issues:
+  - https://github.com/meshery/meshery/issues/14793
+  - https://github.com/meshery/meshery/issues/14794
+  - https://github.com/meshery/meshery/issues/14796
+- LFX URL: 
+
+#### Adapter for AI and LLMs
+
+CNCF - Meshery: Adapter for AI and LLMs (2026 Term 2)
+
+- Description: Meshery is the open source cloud native manager that empowers platform engineers to design and operate infrastructure. As infrastructure complexity grows, the need for intelligent assistance becomes critical. This project focuses on developing and enhancing a dedicated AI Adapter and AI Connections for Meshery. This adapter serves as the bridge between Meshery’s core orchestration engine and various Large Language Models (LLMs). The goal is to enable "Natural Language to Infrastructure" capabilities, allowing users to describe their architectural intent (e.g., "Deploy a highly available Kubernetes cluster on AWS with Prometheus monitoring") and have Meshery auto-generate the visual topology and configuration manifests. The intern will work on decoupling the AI logic from the core platform, allowing users to "Bring Your Own Key" (BYOK)—supporting both cloud-based providers (OpenAI, Anthropic) and local inference runners (Ollama, LocalAI).
+- Recommended Skills:
+  - Proficiency in Golang (Go) is essential, as Meshery’s backend is written in Go.
+  - Familiarity with MCP Servers, REST APIs, LLM APIs (OpenAI, Vertex AI), local inference servers (Ollama).
+  - Basic understanding of Kubernetes, Docker, and Infrastructure-as-Code (IaC) concepts.
+  - Experience with REST, GraphQL, and gRPC.
+  - Nice to have: Experience with React (for frontend integration in Meshery UI).
+- Responsibilities:
+  - Co-design and implement the interface for the AI Adapter in Go to communicate with the Meshery Server.
+  - Implement support for connecting to local LLMs (via Ollama) to ensure data privacy for users who cannot send infrastructure data to the public cloud.
+  - Improve the "System Prompt" and context-window management to feed the LLM relevant data regarding Meshery Models (schema definitions) so the AI generates valid infrastructure configurations.
+  - Write unit and integration tests to ensure the reliability of the adapter.
+  - Create user guides on how to configure the adapter with different AI providers.
+- Expected Outcome:
+  - A fully functional AI Adapter (or Connection) integrated into the Meshery ecosystem.
+  - Demonstrable capability for users to swap between at least two different LLM providers (e.g., OpenAI vs. a local Llama 3 model).
+  - Implementation of a feature where natural language queries result in a rendered design.
+  - Merged pull requests (PRs) including code, tests, and documentation.
+- Mentor(s):
+  - Rian Cteulp (@ritzorama, rian.cteulp@gmail.com)
+  - Lee Calcote (@leecalcote, leecalcote@gmail.com)
+- Upstream Issue: https://github.com/meshery/meshery/issues/19092
+- LFX URL: 
+
+#### Agentic CI Pipelines: GitHub Action Workflow Overhaul
+
+CNCF - Meshery: Agentic CI Pipelines: GitHub Action Workflow Overhaul (2026 Term 2)
+
+- Description: Meshery's CI/CD infrastructure spans a large and growing collection of GitHub Action workflows that have accumulated technical debt - inactive workflows, insecure patterns, and duplicated logic. This internship has two phases: first, a comprehensive audit and restructuring of existing workflows; second, the introduction of [GitHub Agentic Workflows](https://github.github.com/gh-aw/) to bring Continuous AI capabilities to Meshery's repository automation. Agentic Workflows allow automation to be defined in plain markdown and compiled into guardrailed GitHub Actions that run AI agents (Copilot, Claude, Codex) on schedule or in response to events - enabling automated CI failure triage, PR analysis, issue management, documentation maintenance, and compliance scanning with minimal human intervention.
+- Recommended Skills: GitHub Actions workflow authoring, CI/CD concepts, YAML, supply chain security basics (secret hygiene, fork-safe triggers, pinned actions). Interest in AI-assisted automation is a plus.
+- Responsibilities:
+  - Audit all workflows in `meshery/meshery`, cataloging each by type, activity status, and identified issues (duplication, insecurity, staleness).
+  - Produce a structured report with prioritized remediation recommendations, then implement accepted changes - consolidating redundant workflows and hardening insecure patterns.
+  - Author workflow taxonomy definitions (security classification levels, workflow types) for the Meshery Build and Release docs.
+  - Design and contribute agentic workflow definitions using the `gh aw` framework - covering CI failure diagnosis, PR feedback summarization, issue triage, and documentation consistency.
+- Expected Outcome:
+  - Measurably reduced and consolidated workflow set with no inactive or redundant workflows remaining.
+  - Published audit report and workflow taxonomy added to docs.meshery.io.
+  - A suite of agentic workflow definitions (`.md` + compiled `.lock.yml`) committed to the repository, demonstrating Continuous AI applied to Meshery's software delivery lifecycle.
+- Mentor(s): Mia Grenell (@miacycle, mia.grenell2337@gmail.com), Lee Calcote (@leecalcote, leecalcote@gmail.com)
+- Issue: https://github.com/meshery/meshery/issues/18795
+- LFX URL: 
+
+#### Meshery Models Support for OCI Registries
+
+CNCF - Meshery: Meshery Models Support for OCI Registries (2026 Term 2)
+
+- Description: Meshery Models are declarative representations of infrastructure, applications, and their relationships - the canonical artifacts through which Meshery understands and manages cloud native systems. Today, Meshery lacks a standardized, portable distribution mechanism for these models. OCI registries (Docker Hub, AWS ECR, GitHub GHCR, and others) have emerged as the universal artifact store for the cloud native ecosystem, and [ORAS](https://oras.land) (OCI Registry As Storage) provides the Go-native tooling to push and pull arbitrary artifacts to any OCI-compliant registry. This internship implements end-to-end OCI registry support for Meshery Models - from new Connection and Credential types for major registries, to ORAS-powered push/pull logic in the Meshery server, to a redesigned Registry page in the Meshery UI that gives users full visibility and control over their model artifacts across registries.
+- Recommended Skills: Golang, REST API development, React. Familiarity with OCI image specifications, container registries, or ORAS is a plus. Experience with Meshery or other CNCF projects is welcomed but not required.
+- Responsibilities:
+  - Design and implement Connection and Credential types for Docker Hub, AWS ECR, GitHub GHCR, and additional OCI-compliant registries within Meshery's existing connection framework.
+  - Implement Golang server-side logic using the ORAS SDK to push and pull Meshery Models (and their component schemas, relationships, and policies) to and from any OCI-compliant registry.
+  - Define the OCI artifact media types, manifest structure, and layer conventions used to package Meshery Models for registry storage.
+  - Enhance or rewrite the Registry page in Meshery UI to surface connected registries, browsable model artifacts, push/pull controls, and credential management.
+  - Write integration tests covering push, pull, and round-trip fidelity of Meshery Models across at least two registry backends.
+  - Document the new registry integration, artifact format, and UI workflows in Meshery's official documentation.
+- Expected Outcome:
+  - Meshery users can connect to Docker Hub, AWS ECR, GHCR, and other OCI registries using managed credentials and push or pull Meshery Models directly from the Meshery UI and `mesheryctl`.
+  - A well-defined OCI artifact convention for Meshery Models, documented and suitable for adoption by the broader Meshery ecosystem.
+  - A redesigned Registry UI page providing a unified, registry-agnostic interface for model artifact management.
+- Mentor(s):
+  - James Hortison (@hortison, james.hortison@layer5.io)
+  - Lee Calcote (@leecalcote, leecalcote@gmail.com)
+- Upstream Issue: https://github.com/meshery/meshery/issues/19093
+- LFX URL: 
+