SmartForge Studio
SmartForge Studio is the studio where your team builds and maintains functions (tools) that power SmartForge. In simple terms: SmartForge Studio is the workbench used to define what the AI is allowed to do, keep those capabilities consistent, and validate that tool calling stays reliable as things evolve.
What is a function in SmartForge Studio?
Section titled “What is a function in SmartForge Studio?”A function is an approved capability that SmartForge can use at runtime, such as:
- Looking up operational data (orders, inventory, shipments, devices, etc.)
- Running an approved action or workflow (when allowed)
- Calling an enterprise integration (API, command, or script) behind the scenes
In SmartForge Studio, a function is treated as a combination of:
- Implementation (the code or script that runs)
- Metadata (the description, typed inputs, and expected output shape that the AI uses to choose and call it)
Concept
Section titled “Concept”SmartForge Studio focuses on a few core areas:
- Functions: define and maintain tool behavior (metadata + implementation).
- Metadata: keep function definitions understandable and callable (arguments/response shape, descriptions).
- Tags + domains: standardize vocabulary (tags) and field schemas (domains) across many functions.
- Connections: bind functions to real external systems/environments without embedding credentials in code.
- Eval: measure whether the AI selects the right tools and arguments after changes.
- Dev console: troubleshoot builder and tool-calling behavior.
Features (SmartForge Studio scope)
Section titled “Features (SmartForge Studio scope)”Functions (metadata + implementation)
Section titled “Functions (metadata + implementation)”- Browse projects/systems and find functions quickly.
- Edit a function’s metadata: description, inputs (arguments), and outputs (response shape).
- Edit the function implementation (script/API wrapper/etc.), depending on what your environment supports.
Metadata building blocks (tags + domains)
Section titled “Metadata building blocks (tags + domains)”- Tags: categorize functions for discovery and routing (what the tool is “about”).
- Domain fields: reusable field definitions (type, required/optional, enums, descriptions) used by many functions.
- Reusable collections: shared argument/response groups used to keep schemas consistent across tools.
Connections
Section titled “Connections”- View/manage connection records for external systems (per system/environment).
- Use connections to keep credentials/config out of function code while still enabling real integrations.
Eval (tool selection validation)
Section titled “Eval (tool selection validation)”- Run evaluations across selected functions/tools.
- Review results to confirm the AI chose the right tool and filled the right arguments.
- Export/share an evaluation report for review.
Dev console (debugging)
Section titled “Dev console (debugging)”- Inspect troubleshooting details for builder workflows and tool-calling flows (for example: request/session context and debug views).
Common use cases
Section titled “Common use cases”- Developers/builders: create or update functions (metadata + implementation).
- Platform owners: keep tags/domains/collections consistent across teams.
- Integrations engineers: manage connections used by functions.
- QA/test teams: run Eval to validate tool selection after changes.
Typical workflow
Section titled “Typical workflow”- Open a project (connect SmartForge Studio to your functions repository).
- Select a system and choose a function to create/update.
- Update the function metadata (description, arguments, response) and implementation as needed.
- Update tags/domains/collections if your change introduces new fields or categories.
- Ensure the function is wired to the correct connection (if it calls external systems).
- Run Eval to validate tool selection and argument filling before releasing the change.