Open edX AI Extensions with self-hosted models

Open edX AI extensions can run on models you host with Ollama or vLLM, or on a hosted provider. This page covers the scope, setup, review workflow, security and cost decisions behind that choice.

On this page

How Open edX AI extensions fit a learning platform

The Open edX AI Extensions plugin connects an Open edX site to a language model so that learners and course teams can get AI help inside the platform they already use. A team needs it when it wants that help in the LMS or Studio and wants the model, the prompts and any stored conversations to run under its own control, instead of sending learners to a separate chatbot outside the course. The current named release, Open edX Verawood, published on 30 July 2026, added an AI Extensions Framework that the plugin builds on. Confirm the plugin's exact settings, supported releases and configuration keys against its own documentation before you plan the build, because the release notes name the framework but do not describe how the plugin is set up.

The plugin is only as useful as the model behind it, so the first decision is where inference runs. Ollama is an open-source runtime for local models. It listens on 127.0.0.1 port 11434 by default, and its local API has no authentication, so any exposure beyond the host needs a proxy and access controls that you design. vLLM is an inference and serving engine with OpenAI-compatible endpoints, suited to teams that run GPU capacity in their own data center or cloud account. Its --api-key option does not cover every endpoint, and the vLLM security documentation recommends a reverse proxy that allowlists only the endpoints users need. A hosted provider is the quickest to start, but learner prompts then leave your infrastructure, so check the provider's data terms against your own classification rules.

The three use cases place different demands on that choice. A learner assistant answers questions from a course, so you must decide whether it can see graded material, how it declines out-of-scope questions, and what it logs. AI-drafted questions with human review keep a person in the loop: the model writes candidate items, and a named course author or reviewer approves each one before it reaches a learner. Plan that review queue and its role in the access model before the first draft is generated. Prompt templates per course let each course team set its own instructions, for example a tone or a rule against giving final answers outright. Each template needs an owner, a version history and a review date, because a silent edit changes what every learner in that course receives.

Start with one course and one model source, and treat the pilot as a test of the decision as well as of the software. Record which data leaves the platform, who can change prompts, where conversation records are kept and for how long, and who responds when a learner reports a wrong or harmful reply. Ask the plugin maintainers to confirm which Verawood configuration keys and model endpoints are supported for each option. Where a team cannot yet answer these questions, the model choice should wait until it can.

Choosing a model host for Open edX AI extensions

This table compares Ollama, vLLM and a hosted provider for the model behind Open edX AI Extensions, across who operates the infrastructure, where prompts go, how access is controlled, cost components and team fit. Read each row against your own hosting constraints. The main takeaway is that the right choice depends on the model, hardware and concurrency needs your implementation confirms, so treat these cells as the starting point for that decision.

AspectOllamavLLMHosted provider
Who runs the infrastructureYour team runs the Ollama server on hardware you provideYour team runs the vLLM server and the GPU or accelerator nodesThe provider runs inference; your team runs the integration and keys
Where prompts and data goStay on your server when run locally, and Ollama states it does not see local promptsStay on the nodes you deploy to, inside the network you isolateSent to the provider's cloud; confirm retention and processing terms in writing
How access is controlledThe local API at localhost:11434 has no authentication, so add a proxy with access control before exposing itThe --api-key option covers /v1 endpoints only; place a reverse proxy in front that allowlists user endpointsEvery request needs a Bearer API key; store keys in your secrets management system
Cost componentsSoftware is MIT licensed; hardware is yours; cloud model plans are paid separatelyApache-2.0 with no paid edition; you pay for GPU capacity, infrastructure and operationsUsage fees set by the provider's terms; ask for pricing, quotas and rate limits in the quote
Concurrency and scalingParallel requests per model are set by OLLAMA_NUM_PARALLEL, which defaults to 1Tensor parallelism within a node and pipeline parallelism across nodesScaling is handled by the provider; confirm limits and throughput commitments
Teams it fitsTeams testing with small or single-user loads, or keeping data on a workstation or serverTeams with GPU capacity, operations skills and multi-user concurrency needsTeams that accept external processing and do not want to host models
Confirm before choosingModel support, hardware fit and parallelism settings for your course volumeModel compatibility, accelerator support and parallelism for your hardwareModel catalog, data terms and rate limits, agreed in writing before build

How the AI Extensions plugin connects Open edX to a model

The AI Extensions plugin makes one outbound call per AI feature. When a learner or course author triggers an AI feature, the LMS or Studio sends a request to the model endpoint configured for that instance. The endpoint returns a completion, and the plugin displays that text to the learner or author. Every other design decision follows from this path: which application servers send the request, which address they reach, what credentials they carry, and what the interface shows while the model is working. For a self-hosted model, the endpoint is the Ollama or vLLM server you run, so the first decision is which network zone it sits in and which LMS and Studio hosts are allowed to reach it.

The endpoint address, model name and credentials are set in the plugin's configuration, which Tutor renders into the LMS and Studio settings during deployment. The exact setting names, and whether the plugin reads separate values for learner features and author features, must be confirmed in the plugin's documentation for your Verawood installation, along with the plugin version that supports Verawood. Store credentials in your deployment's secret mechanism, not in course content or in shared configuration files that many people can read. Protect the endpoint itself as well. The local Ollama API on port 11434 needs no authentication and binds to 127.0.0.1 by default, so reaching it from application containers means changing its bind address and adding a firewall rule. The vLLM --api-key option covers only some paths, so place a reverse proxy in front of vLLM that exposes only the routes the plugin calls.

Tutor is the official Docker-based distribution for Open edX, and its plugin and hooks system is licensed under Apache 2.0. A Tutor plugin is installed into the Tutor environment, enabled, and then applied by regenerating the configuration and images and redeploying the platform. The exact install and enable commands depend on your Tutor release, so confirm them in the Tutor documentation before you schedule a change. Because a plugin that changes settings also changes the rendered configuration, treat every plugin change as a platform change. Pin the plugin version to one tested against your Verawood images, run the change in a non-production environment first, and keep the previous configuration so you can roll back the plugin without rebuilding the rest of the platform.

Verawood added new frontend plugin slots, and that is the reason the integration can place AI elements in the interface without changing core platform code. Slots are defined points where micro-frontends accept additional components, so a plugin can add a learner assistant or an author tool in the right place and keep its code separate from the platform's. Confirm which slots the plugin uses in Studio and in the LMS, and confirm that those slots exist in the Verawood release you run. Then plan for the failure case. If the model endpoint is slow, overloaded or unreachable, the component must show a clear message and let the page keep working. Test that behavior with the endpoint stopped and with a slow endpoint before any learner sees the feature, since a page that waits on a model call can make the whole course experience feel broken.

Setting up Open edX AI extensions with a self-hosted model

This sequence takes a self-hosted model from a confirmed Open edX release to a tested AI Extensions setup in staging. Each step ends with a check, so the team can stop before a fault reaches learners. Production changes follow only after the sample course tests pass.

  1. Confirm the Open edX release and Tutor version

    The platform team confirms which named Open edX release the instance runs and which Tutor version deploys it. The AI Extensions Framework arrived with Verawood, and Open edX supports only the latest named release, so Verawood, published 30 July 2026, is the reference point for this sequence. Read the plugin's compatibility notes for that release before any installation. Done when the release, Tutor version and plugin version are recorded in the change record and match the staging target.

  2. Choose and size the model host

    Decide which runtime fits the workload. Ollama is a local runtime for models with a REST API, while vLLM is a serving engine that can spread a model across GPUs and nodes. Size memory and accelerators for the model you plan to use, and ask the model publisher or runtime documentation for its memory requirements, since this page does not give them. Place the host in the same private network zone as the LMS and Studio hosts, with no public address. Done when the platform and security owners approve the host, its accelerator plan and its network placement.

  3. Install and bind the runtime with access restricted

    Install the runtime on the model host and keep it off public interfaces. Ollama binds to 127.0.0.1 on port 11434 by default and its local API needs no authentication, so change the bind address with OLLAMA_HOST only to a private interface, and put an authenticating proxy you control in front of it. Set OLLAMA_NO_CLOUD=1 so inference stays on the host. For vLLM, start vllm serve on a private address with --api-key, then add a reverse proxy that allowlists only the endpoints the plugin calls, because the key does not cover /metrics or /health. Check: a request from the LMS host succeeds, and the same request from an outside network fails.

  4. Pull and test the model outside Open edX

    Download the chosen model onto the host and send requests directly from the host shell, before Open edX is involved. Ollama stores models in a default directory for each operating system, and OLLAMA_MODELS moves them, so place them on a volume that is sized and backed up. Set OLLAMA_NUM_PARALLEL and OLLAMA_MAX_QUEUE to match expected course traffic, noting the defaults of 1 parallel request per model and 512 queued requests. Check: the model returns a coherent answer to a fixed test prompt through the OpenAI-compatible route, and the latency is recorded for later comparison.

  5. Install the AI Extensions plugin in staging

    Install the AI Extensions plugin on a staging instance built from the same Tutor configuration as production, using the plugin workflow in the Tutor documentation. Keep production out of this step. Read the plugin's settings and identify the two flows to test: the learner assistant and AI-drafted questions with human review. Check: the services start cleanly with the plugin enabled, and the plugin's configuration screens load for an administrator account.

  6. Point the plugin at the self-hosted endpoint

    Enter the address of the authenticating proxy in the plugin configuration, and use the proxy address in place of the runtime port. Leave any hosted provider option disabled so that prompts and course content stay on the model host, and confirm this in the plugin settings. Set the credential the proxy expects through your secrets process, not in plain configuration files. Check: a test call from the LMS host reaches the model, and the proxy and runtime logs show the request, with no outbound call to an external AI service.

  7. Test assistant and question-drafting flows with a sample course

    Build a small sample course in staging with a few units, then run the learner assistant and the question-drafting flow against it. Confirm that the assistant answers only within the scope you defined for the course. Ask the drafting flow for questions based on one unit, and check that each draft appears in a review queue for a course author and does not appear in the published course until a person approves it. Check: a draft question appears in the review queue, the published course is unchanged, and the assistant's replies stay within the agreed scope.

Setting learner assistant scope in Open edX AI extensions

A learner assistant answers whatever its prompt allows, so its boundaries are configuration decisions made before launch, not defaults to accept. The cards below cover the scope, data and retention choices that most affect learners, course teams and the institution's policy owners.

Course-only content versus general questions

Decide whether the assistant answers only from the current course material or also answers general subject questions from the model's own knowledge. A course-only setting keeps answers aligned with what instructors certified, while a general setting can give learners confident answers that contradict the course. Confirm with the plugin documentation how course context is supplied to the prompt and what the assistant does when that context is missing.

Access to graded items

Decide whether the assistant can see problem text, answer keys or hints attached to graded components. If it can, a learner may obtain answers directly, which undermines assessment integrity. Confirm whether the plugin can exclude graded blocks from retrieved context, and whether that exclusion is applied per course or per block type.

Handling off-topic and assessment requests

Define the refusal behavior for requests unrelated to the course and for requests to complete or write graded work. Leaving this open means the model decides case by case, which varies between runs. Ask the policy owner for the wording of the refusal, the escalation path to instructors, and whether refusals are logged for review.

Conversation storage and retention period

Decide whether learner conversations are stored, where they sit, who can read them and how long they are kept. Storage may fall under the institution's records schedule and student privacy obligations even when the model runs on your own hardware. Confirm with the plugin documentation which tables or logs hold transcripts and whether a retention setting or deletion command exists.

Learner data included in prompts

Decide which learner attributes reach the model, such as name, username, enrollment, progress, or prior answers. Each field sent into the prompt is also written to any log that records prompts. Confirm with the plugin documentation the exact fields included by default, and ask the policy owner which fields may be used for personalization.

Model endpoint and logging behavior

Decide which model endpoint receives prompts and whether request logs at the serving layer record prompt content. A self-hosted runtime keeps prompts inside your network, but a hosted provider or a cloud feature switched on by default would change the data path. Confirm the endpoint in the plugin settings, the logging level on the runtime, and whether cloud features are disabled in your deployment.

AI-drafted questions and human review in Open edX AI extensions

Course teams can use the self-hosted model to draft question text, distractors and feedback for problems they then edit in Studio. The model saves drafting time, but it does not know which learning outcome a question must test, whether a distractor is accidentally correct, or whether the feedback matches the course's own explanation. For that reason, every draft should pass a named reviewer before it reaches a learner. Name that person in writing, give them authority to reject a draft, and make sure they are not the same account that prompted the model. Treat the output as a first draft, and decide before rollout which course roles may generate drafts at all.

Each course should have its own prompt template. A template captures the course subject, the learner level, the question types the course uses, the target reading level and the tone of feedback. These fields keep drafts consistent across a course team and make each output easier to check against the course objectives. Store templates in version control or in the configuration repository your operators already manage, with a version number for every change. Record the template version on each draft so a reviewer can see which instructions produced it. To reuse templates, start from an approved base and fill in only the course-specific fields, so a change to the base is made once, on purpose, and reviewed before it spreads.

Keep one course's material out of another course's template. Do not paste source text, answer keys or learner data from a finished course into a template for a new one, and do not share a template between courses with different audiences or confidentiality needs. Confirm with your implementer how the AI Extensions Framework assembles context for each request, including whether it sends course content beyond the problem being drafted, and which logs capture prompts and responses. Self-hosting keeps inference on your infrastructure, but application logs, caches and shared dashboards can still mix material across courses. Test this before launch by drafting a question in one course and checking that no phrase from a second course appears in the output or the logs.

Define the review workflow in writing before enabling drafting. Decide who approves: normally the course author who owns the learning outcome, plus a subject reviewer who did not write the draft. Decide where drafts live: in a state that learners cannot see, such as a separate draft store or an unpublished component, and confirm in your setup that a draft cannot reach a live course by accident. Decide how rejected drafts are recorded: keep the draft, the reviewer, the reason code, the template version and the date. Those records show patterns, such as distractors that are repeatedly too close to the correct answer, and they let auditors see the control operating. Ask your implementer to include these records in the written scope and to confirm which of them the framework supports natively.

Limits to confirm before you commit to an Open edX AI design

An AI design for Open edX depends on the plugin version, the model runtime and the course context it will run in. The cards below list the items your team should test in its own environment before it commits to a design, because a result that holds in a demo may not hold for your courses, languages or peak learner load.

Features in the installed plugin version

The AI Extensions Framework arrived with the Verawood named release, but the AI features available to you depend on the plugin version you install. Ask which learner-facing and author-facing features that version includes, which ones are still experimental, and which settings must be enabled separately. Record the exact plugin version in your design document so the feature list stays tied to a known build.

Runtime API compatibility

Confirm that the plugin can call the API shape your chosen runtime exposes. Ollama serves its own REST API on port 11434 and offers OpenAI compatibility, while vLLM serves OpenAI-compatible endpoints such as chat completions and responses. Check the exact endpoints, request fields and streaming behavior the plugin uses, and test them against the runtime version you plan to deploy.

Accuracy on your course subject

A general-purpose model may answer introductory questions well and fail on specialist material, such as clinical protocols or statistical methods. Build a test set from your own course content, including questions with known answers and questions that should be refused or escalated. Score the outputs with subject experts before any learner sees them, and rerun the set after every model or prompt change.

Language coverage

Check each language your learners use, including the language of course materials, assessment questions and learner queries. Model quality often varies by language, and a model that performs well in English may produce weaker explanations or incorrect terminology elsewhere. Ask the model vendor which languages were evaluated, then test your own content in each one.

Interaction with grading

Decide whether AI output can affect a grade, and document the answer. Assistant responses that hint at answers can change how learners attempt graded problems, and AI-drafted questions need human review before they enter an assessment. Confirm where the plugin stores AI output, whether learner prompts are logged, and how a problem author can turn off AI assistance on a graded component.

Concurrent learner capacity

Estimate peak concurrent requests from your enrollment and course schedule, then load test the runtime at that level. Ollama limits parallel requests per model by default and queues requests up to a configured maximum, and vLLM throughput depends on accelerator capacity, batching and context length. Measure latency and queue behavior, not only average throughput, and set a clear fallback for when the queue fills.

Compatibility at each upgrade

Open edX supports only the latest named release, so the plugin must be checked against each new release before you upgrade the platform. Verawood is the current named release, and Willow and Xylon follow in later periods. Plan a compatibility test in staging for each upgrade, and confirm with the plugin maintainers that the AI Extensions version you run supports the target release.

What drives cost and effort for self-hosted AI in Open edX

Cost for self-hosted AI in Open edX comes from five places, and only one of them is a licence. The first is accelerator or server capacity. A vLLM deployment needs GPU, ROCm or other supported accelerator capacity sized to the models and to the number of learners using the assistant at once, while an Ollama deployment can run smaller models on ordinary server hardware. The second is storage for model files, which grows with each model you keep for testing or rollback. The third is the surrounding infrastructure: the Tutor-based Open edX hosting, a reverse proxy that exposes only the endpoints learners need, and logging. On licences, Ollama's pricing page states that running models on your own hardware is always unlimited. Its cloud plans (Pro at $20 per month or $200 per year, Max at $100 per month, Team at $500 per month, and Enterprise at custom pricing) apply only if you call its hosted models. vLLM has no paid edition, so its cost is the hardware and the people who run it.

Implementation is the one-time part, and its size depends on decisions made before any configuration begins. Start with the learner assistant scope: which pages it answers on, what it declines to answer, and whether it can see learner data. Then design the review workflow for AI-drafted questions, including who approves a draft, where drafts wait until approved, and how rejections are recorded. Each course with its own prompt template adds authoring and review time, so count the courses in the first release. The build also covers plugin configuration in the Tutor setup, network controls (Ollama's local API has no authentication, so it must stay on 127.0.0.1 or a private address set through OLLAMA_HOST), and concurrency settings such as OLLAMA_NUM_PARALLEL and OLLAMA_MAX_QUEUE. Testing covers draft quality, review gates, behavior when the model is slow or unavailable, and access controls.

Recurring work starts with runtime upgrades. vLLM ships new minor releases about every two weeks, including v0.28.0 on August 26, v0.29.0 on September 9, v0.30.0 on September 22 and v0.31.0 on October 5, 2026. Ollama also ships frequent releases, including v0.40.5 on 14 October 2026. Each upgrade needs a regression run against the review workflow and the question test set. Model updates are the second recurring item, because a new model version can change draft quality, so repeat the quality tests before switching. Monitoring is the third. vLLM exposes Prometheus-format metrics at /metrics covering request counts, token throughput, latency and KV cache use, and someone must watch those metrics along with Ollama's queue behavior. Prompt maintenance follows course changes. Assign a named owner to each item, because unowned monitoring and stale prompts are where running costs tend to grow without anyone noticing.

A quote should follow from a written scope, and the scope should state the assumptions behind the price. Ask for the model names and parameter sizes, the accelerator type and count or the CPU and memory profile, the expected number of concurrent learners, the Ollama or vLLM settings assumed, and whether any hosted provider is included. Ask for the test plan: functional tests of the learner assistant, acceptance tests for AI-drafted questions through the review gate, a load test at the concurrency you specified, and failure tests for model timeouts. Ask the vendor to separate one-time costs from recurring ones, and to state who operates the system after handover. DeployOpen works to fixed scope agreed in writing before work starts, and retainers are available for ongoing upgrades, monitoring and testing. A quote without these assumptions cannot be compared with another.

Securing model endpoints that serve Open edX learners

The risks in this section sit at the edges of the model host: the port that serves inference, the paths a proxy exposes, the network between nodes and the keys that reach hosted providers. Each card names one exposure and the check to confirm before learners use the assistant.

Ollama local API has no authentication

Ollama binds to 127.0.0.1 on port 11434 by default, and its local API accepts requests without authentication. If the Open edX AI Extensions plugin runs on a different host, or you change OLLAMA_HOST to expose the service, place a reverse proxy in front of it with access control and an allowlist for the paths the LMS calls. Confirm that port 11434 is closed on every other interface.

vLLM API key covers only some paths

The --api-key option protects the /v1, /v2, /inference and /cohere routes, but it does not protect /invocations, /pause, /resume, /abort_requests, /metrics or /health. The vLLM security docs advise against relying on the key alone and recommend a reverse proxy that allowlists only the endpoints meant for users. Confirm that the proxy blocks the unprotected paths and that metrics and health checks are reachable only from your monitoring network.

vLLM multi-node traffic is unprotected

In a multi-node vLLM deployment, communication between nodes is insecure by default, with no authorization or encryption. Pipeline parallelism across nodes sends traffic between them, so the nodes need an isolated network that only the cluster can reach. If you add a GPU host later, treat the inter-node network as a trust boundary and keep learner traffic on a separate path.

Hosted provider keys sent as Bearer tokens

Direct cloud inference at ollama.com/api and ollama.com/v1 requires an API key sent as a Bearer token. Store that key in a secrets manager and keep it out of course content and shared configuration files. Rotate it when staff change, and limit the services that hold it, since any service with the key can spend against the provider account.

Disable cloud features with OLLAMA_NO_CLOUD

Ollama states that setting OLLAMA_NO_CLOUD=1, or the matching entry in the server configuration file, turns off cloud features. If learner data must stay on your infrastructure, set it on every Ollama host and test that no cloud model can be selected from the plugin. Record the setting in your configuration baseline so that new hosts and upgrades carry it forward.

Learner prompt data path

Ollama states that when it runs locally it does not see your prompts or data. The full path still depends on the code around it: the plugin sends learner input to whichever endpoint is configured, and a hosted provider receives that text too. Map each hop from the LMS to the model host, record what each component logs, and confirm retention terms with each provider before pilot learners use the assistant.

Questions teams ask before adding AI to Open edX

How much does an Open edX AI Extensions pilot cost?

The cost has three parts: implementation work, model infrastructure, and the people who run the system afterward. Implementation is quoted from a written, fixed scope, so the figure depends on which features, courses and model options you select. DeployOpen does not publish a price list. Model infrastructure varies by runtime. Ollama is MIT licensed and its pricing page states that running models on your own hardware is always unlimited, so the main cost is the server, memory and, for larger models, GPU capacity. vLLM is Apache-2.0 licensed with no paid edition, so its cost comes from accelerator capacity, surrounding infrastructure and the operators who maintain it. Ask every quote to separate one-time setup from recurring hosting, model updates and support, and to show which items change when you add courses or learners.

How long does a pilot take, and what sets the length?

A pilot's length is set by the written scope, which is agreed before work starts, so ask for the timeline to be stated there. The main drivers are the model runtime you choose, since Ollama and vLLM differ in setup and hardware needs; whether GPU or server capacity is already available or must be procured; how many courses need prompt templates; whether named reviewers are available before the build begins; and whether a hosted provider is used, which removes most hardware work. Each of these can add waiting time that is outside the build itself. Ask for the timeline to list each dependency on its own line, especially hardware lead times, access approvals and reviewer availability, so you can see which items move the date.

Can our internal team install and run the AI Extensions?

A capable internal team can do it, but the work spans more than Open edX. The edx-platform maintainers recommend running Open edX in production through a service provider or with Tutor, because bare-metal installation is complex and has limited community support, so Tutor is the practical starting point. The model layer adds further skills. Ollama's API on localhost:11434 has no authentication, so exposing it needs a proxy and access controls. vLLM is insecure by default between nodes in a multi-node deployment, so those nodes need an isolated network. Teams also need to operate GPU hosts, expose metrics at /metrics and monitor queues. Check your staff against each of these areas before deciding whether to build in-house, run a pilot with a partner, or combine the two.

What must our team supply for an AI pilot?

Your team supplies four things: course content, named reviewers, hosting, and a decision on learner data. Course content is the source for the learner assistant and for AI-drafted questions, so it should be final enough to review. Reviewers must be named people with time in their calendars, because drafted questions need their approval before learners see them. Hosting means a server or GPU host inside your infrastructure, or an account with a hosted provider. The learner data decision matters most. Ollama states that when it runs locally it does not see your prompts or data, while direct cloud inference at ollama.com requires an API key and sends requests to that service. Decide, before design starts, which path is allowed, and confirm the data flow in the plugin documentation and with your privacy and legal teams.

Is a hosted model provider cheaper than self-hosting?

It depends on usage, and no fair answer exists without volume estimates. A hosted provider replaces hardware and operations with a usage or subscription charge. Ollama's pricing page lists cloud plans, including Pro at $20 per month ($200 per year), Max at $100 per month, Team at $500 per month and Enterprise at custom pricing, and its local runtime is free to run on your own hardware. Self-hosting shifts the cost to GPU or server capacity, power, operations time and the risk of outages. Compare a hosted plan against your expected number of learner requests, the models you need, peak concurrency and the staff time to run the stack. Also weigh data residency, since a hosted path sends prompts outside your environment. Ask the provider for its usage limits and terms in writing.

How do we keep AI-drafted questions under human control?

Treat every AI draft as unpublished until a named reviewer approves it. The control depends on how the plugin stores drafts, who can publish them and whether the review is recorded, so confirm each point in the AI Extensions plugin documentation before the design is final. Prompt templates set per course should state the subject, level and question format, and they should be versioned so reviewers can see which template produced a draft. Plan a review step for each course, with a reviewer who can reject or edit questions and a record of changes. Also decide who may edit prompt templates, because a template change alters every future draft. Test the workflow with a small set of courses before scaling, and keep the review evidence as part of your records.

Which Open edX release should the AI Extensions target?

Target Verawood, the current named release, which was published on 30 July 2026 and added an AI Extensions Framework. Open edX states that the latest named release is the only supported release and that it cannot support more than one release at a time, so your platform must run the release the plugin supports. Confirm the plugin's version compatibility with Verawood in its documentation before planning the build. Plan the upgrade path now as well, since the next named releases, Willow and Xylon, are listed for December 2026 and June 2027. Each upgrade may change the framework or the plugin, so budget for regression testing of the AI features on every upgrade, not only the core platform.

What breaks first when learner traffic grows during a course?

Request queues and model concurrency usually fail first, and the defaults set the limits. Ollama allows 1 parallel request per model by default, keeps up to 3 models loaded per GPU or 3 on CPU, and queues up to 512 requests, so a busy course can hit these limits quickly unless OLLAMA_NUM_PARALLEL and related settings are raised and tested. vLLM exposes Prometheus metrics at /metrics covering request counts, token throughput, latency and KV cache use, which show where the queue builds. Learner-facing endpoints also need care, because vLLM's --api-key option does not protect every endpoint, and its docs recommend a reverse proxy that allowlists only the endpoints meant for users. Run a load test that matches your expected peak before launch, and confirm each limit with the vendor documentation for your versions.

How DeployOpen scopes and delivers Open edX AI extensions

DeployOpen plans the AI extensions as a written scope tied to your Open edX release, your chosen model runtime and your course teams' review process. The work is built and tested inside infrastructure you control, then handed over with documentation your operators can run.

How we scope

  • Confirm which AI features are in scope: learner assistant, AI-drafted questions with human review, or prompt templates per course
  • Record the Open edX release and Tutor version the extensions will run on, since support follows the latest named release
  • Choose the model path in writing: self-hosted Ollama, self-hosted vLLM, or a hosted provider, with the reasons for each
  • Agree which course teams, roles and review steps approve AI-drafted content before learners see it

How we build

  • Install and configure the AI Extensions plugin in a non-production environment that mirrors your LMS and Studio setup
  • Connect the model endpoint, and restrict vLLM traffic through a reverse proxy that allowlists only the user-facing endpoints
  • Build per-course prompt templates and test them against sample courses, including refusal and off-topic cases
  • Run functional, access and load tests on the model endpoint before any learner-facing rollout

How we hand over

  • Deliver configuration records, prompt template inventory, network and access diagrams, and the model runtime setup
  • Document the review workflow for AI-drafted questions, including who approves, who can edit templates and how changes are logged
  • Provide runbooks for model loading, concurrency settings, metrics collection and rollback to a previous configuration
  • Walk your operators and course leads through the handover so the team can run the setup without DeployOpen present

How we support

  • Track Open edX and Tutor release changes that affect the AI Extensions plugin and the model runtime you chose
  • Offer ongoing support, upgrades and continuous testing as a retainer, separate from the fixed-scope build
  • Re-test prompt templates and endpoint access after model, runtime or plugin version changes
  • Confirm pricing, response terms and the support channel for your environment with DeployOpen before the work starts

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.