PARTNER ADMIN GUIDE
Configure AI providers and tools
Connect the models, credentials and external capabilities a tenant's Greentic solutions can use. Configure scope, access and allowed operations carefully so each team, flow and agentic worker receives only the capabilities it needs.
Scope: individual tenant
How AI and tools fit together
AI & Tools brings together three related layers.
- Models
- AI providers supply the language or embedding models used by supported Designer capabilities.
- Authorisation and packaged capabilities
- OAuth apps provide delegated access to external services, while extensions provide prebuilt Greentic tool packages.
- Connected and custom tools
- MCP servers, component tools and OpenAPI connectors expose external actions to flows and agentic workers. The GitHub App connects repositories to Greentic Actions.
Designer surface
↓
Model or tool capability
↓
Tenant or team scope
↓
Allowed roles, tools or operations
↓
Runtime executionChoose the right option
| Requirement | Configure |
|---|---|
| Use an LLM for supported Designer capabilities | AI provider |
| Create embeddings for supported search or knowledge capabilities | AI provider with the appropriate type |
| Let users authorise an agent to act through an external service | OAuth app |
| Use a prebuilt Greentic capability | Extension |
| Connect an existing remote tool server | MCP server |
| Expose a gtc or Wasm component as a tool | Component tool |
| Build a connector component from an API specification | OpenAPI connector |
| Trigger Greentic Actions from repository activity | GitHub App |
Guides in this section
Add an AI provider
Connect an LLM or embedding model and control where it can be used.
Configure an OAuth app
Register delegated authorisation settings for an external provider.
Manage extensions
Find, configure, enable and scope installed tool extensions.
Connect an MCP server
Add a remote server, restrict its tools and choose its Designer surfaces.
Register a component tool
Expose selected operations from a gtc or Wasm component.
Create an OpenAPI connector
Generate a connector component from an OpenAPI or Swagger specification.
Connect the GitHub App
Understand the deployment prerequisite and connect repositories when available.
Before you begin
- Open the correct customer tenant before changing AI & Tools settings.
- Confirm whether the capability should be tenant-wide or limited to a team.
- Obtain the required provider credentials, OAuth configuration, server URL, component reference or API specification.
- Decide which Designer surfaces genuinely require access.
- Use test credentials and non-production integrations while validating a new setup.
Add an AI provider
AI providers connect an LLM or embedding model to the tenant. Provider roles determine which supported Designer surfaces may use that provider.
- Type
- Select the model capability being connected, such as an LLM or embedding provider.
- Provider
- Select the model provider. Treat the providers visible in the screenshot as examples rather than a permanent list.
- Model
- Enter the exact model identifier supported by that provider.
- Label
- Give the connection a clear administrative name.
- Base URL
- Leave the default where appropriate, or set the endpoint required by a compatible service, gateway or self-hosted model.
- API key
- Enter the credential issued for this tenant or environment.
- Tenant access
- Control whether teams or individual flows may override the tenant default.
- Designer roles or surfaces
- Grant the provider only to the capabilities that require it.
- 1Open the tenant.
- 2Select AI & Tools.
- 3Open AI providers.
- 4Select Add provider.
- 5Choose the provider type and provider.
- 6Enter the exact model identifier.
- 7Add a descriptive label.
- 8Review the base URL.
- 9Enter the API key.
- 10Choose the tenant access policy.
- 11Select the required Designer roles or surfaces.
- 12Create the provider.
- 13Confirm that it appears as enabled and has the expected roles.
Configure an OAuth app
An OAuth app registers the customer or provider application Greentic uses when a user authorises an agent to act through an external service. Creating the OAuth app does not by itself grant access to a user's account; the user authorisation step still needs to occur where supported.
- Provider identifier
- The external service being registered.
- OAuth application kind
- The credential model used by that provider.
- Optional team slug
- Limits the configuration to a single team when required.
- Tenant access policy
- Whether teams or flows may override the tenant default.
- Client credentials
- The client ID and secret issued by the external provider.
- Requested scopes
- The permissions requested during user authorisation.
- Authorisation URL
- The endpoint where the user grants access.
- Token URL
- The endpoint used to exchange and refresh tokens.
- 1Open AI & Tools → OAuth apps.
- 2Select Add OAuth app.
- 3Enter the provider identifier.
- 4Select the appropriate OAuth application kind.
- 5Add a team slug only when the configuration should be team-specific.
- 6Choose the tenant access policy.
- 7Enter the client credentials.
- 8Add only the scopes required by the intended tools.
- 9Confirm the authorisation and token endpoints.
- 10Create the OAuth app.
- 11Complete a test user authorisation before relying on it in a solution.
Manage extensions
Extensions are prebuilt Greentic tool packages installed for a tenant. Treat visible extension names, counts and versions as examples only.
- Scope
- Selects the tenant default or another supported scope.
- Search and filters
- Help administrators find an extension by name, publisher, domain or status.
- Browse store
- Used to discover available extensions.
- Setup
- Opens extension-specific deployment and credential settings.
- Toggle
- Controls whether the extension is enabled for the selected scope.
- Team
- Select tenant-wide or a supported team scope.
- Environment
- Choose the relevant runtime environment.
- Deploy pack ID
- Enter the pack identifier expected by the runtime.
- Credentials
- Add the aliases and secret values required by that extension.
- 1Open AI & Tools → Extensions.
- 2Select the correct scope.
- 3Search for the extension or select Browse store.
- 4Install the required extension where it is not already installed.
- 5Select Setup.
- 6Choose the team and environment.
- 7Enter and save the deploy pack ID.
- 8Add the required credentials.
- 9Close the setup dialog.
- 10Enable the extension.
- 11Test one representative tool operation.
Connect an MCP server
MCP servers expose remote tools to the tenant's Designer surfaces.
- Add from store
- Select a packaged MCP integration where available.
- Add server
- Connect a remote MCP endpoint manually.
The two screenshots below are the upper and lower parts of the same Add server form.
- Name
- A stable administrative name for the server.
- Transport URL
- The remote MCP endpoint.
- Scope
- Tenant default or a selected team.
- Tenant access
- Whether teams or flows may override the tenant default.
- Authentication header name
- The HTTP header expected by the server.
- Authentication token
- The sealed credential sent to the server. It may be left blank for a public tokenless server.
- Allowed tools
- A tool allow-list. An empty value exposes every tool reported by the server.
- Enabled
- Controls whether the server is available.
- Designer surfaces
- Select Flow Editor, Agentic Worker or both where supported.
- 1Open AI & Tools → MCP servers.
- 2Select Add server.
- 3Enter a clear server name.
- 4Enter the transport URL.
- 5Choose tenant-wide or team scope.
- 6Review the tenant access policy.
- 7Add the authentication header and token where required.
- 8Restrict the allowed tools where possible.
- 9Enable the server.
- 10Select the Designer surfaces allowed to use it.
- 11Create the server.
- 12Confirm its status and test a permitted tool.
Register a component tool
Component tools register a gtc or Wasm component from a store, OCI registry or repository URL. Greentic inspects its operations and exposes permitted operations as tools.
The page has two areas: Component tools, where components are registered, and Registry credentials, where private-registry access is stored.
- Name
- A clear administrative name for the component.
- Source URL
- The store, OCI or repository URL of the component.
- Component reference
- Optional reference identifying the component.
- Version
- Optional component version.
- Digest
- Optional digest that pins an exact build.
- Allowed operations
- An empty value exposes every operation reported by the component, while an explicit list limits what is available.
- Enabled status
- Controls whether the component tool is available.
- 1Open AI & Tools → Component tools.
- 2Add a registry credential first when the source is private.
- 3Select Add component tool.
- 4Enter a clear name.
- 5Enter the store, OCI or repository source URL.
- 6Add the component reference, version or digest where required.
- 7Restrict the allowed operations.
- 8Enable the component.
- 9Create the component tool.
- 10Confirm that its operations can be inspected and exposed.
Access a private component registry
- Registry host
- The host serving the private packages.
- Username
- The service or bot account used for the pull.
- Registry token
- A token with only the required package-read permissions.
- 1Select Add credential.
- 2Enter the registry host.
- 3Enter the service or bot username.
- 4Enter a token with only the required package-read permissions.
- 5Create the credential.
- 6Return to the component tool and retry registration.
Create an OpenAPI connector
This feature generates a connector component from a specification. It is not the same as connecting directly to a remote MCP server. The resulting component can subsequently be registered and exposed as a tool.
- 1Open AI & Tools → OpenAPI connectors.
- 2Select New connector.
- 3Enter a concise connector name.
- 4Select a supported OpenAPI or Swagger specification file.
- 5Select Upload spec.
- 6Review the generated connector's status and component information after processing.
- 7Correct the specification and upload it again if validation fails.
- 8Register or configure the resulting component as required by the tenant.
Connect the GitHub App
The GitHub App connects repositories to Greentic Actions so supported repository activity, such as pushes, can trigger flows.
- Platform administrator
- Configures the deployment-level GitHub App credentials.
- Partnership administrator
- Can connect the tenant only after that prerequisite is complete.
- The state shown
- The screenshot represents an unavailable prerequisite state, not a successful connection.
- 1Open AI & Tools → GitHub App.
- 2Review the displayed status.
- 3Select refresh to check the deployment configuration again.
- 4When the page says the GitHub App is not configured on the deployment, contact the Greentic platform administrator.
- 5Ask the platform administrator to configure the App ID, app slug and private key.
- 6Return to the tenant and refresh the status.
- 7Continue with the repository connection controls that become available after the deployment prerequisite is satisfied.
Recommended setup order
- 1Add and validate the required AI provider.
- 2Decide which capabilities are tenant-wide and which are team-specific.
- 3Configure OAuth or other credentials.
- 4Install and configure prebuilt extensions.
- 5Connect MCP servers or register custom components.
- 6Generate OpenAPI connectors where an existing API specification is available.
- 7Restrict roles, tools, scopes and operations.
- 8Test every capability from the Designer surface that will use it.
- 9Test using a normal tenant user where possible.
- 10Review secrets and permissions before production use.
Troubleshooting at a glance
| Problem | Likely cause | Action |
|---|---|---|
| A model does not appear in Designer | The provider is disabled or the required Designer role was not selected | Edit the provider and review its status and role assignments |
| An OAuth connection fails | Incorrect client credentials, scopes or provider endpoints | Compare the app configuration with the external provider's settings |
| An extension cannot be enabled | Deploy pack ID or required credentials are missing | Open Setup, save the deploy pack and add the required credentials |
| An MCP server connects but its tools are missing | Allowed tools excludes them or the required Designer surface is not selected | Review the allow-list and surface checkboxes |
| A component cannot be inspected | The source reference is invalid or the private registry cannot be accessed | Check the source URL, version and registry credential |
| An OpenAPI connector fails to build | The uploaded specification is invalid or inconsistent | Validate and correct the specification, then upload it again |
| A saved secret is no longer visible | Secrets are intentionally sealed or masked | Replace the credential when necessary rather than expecting to retrieve it |
| The GitHub App cannot be connected | Deployment-level GitHub App credentials are absent | Contact the platform administrator and refresh after configuration |
