Skip to main content
Glama
dizzydes

0pi-mcp-server

by dizzydes

create_object

Save objects to ephemeral cloud storage for temporary data sharing and workflow bridging. Get a shareable URL that expires in 2 hours to store reasoning states, JSON structures, or session data.

Instructions

Save objects to ephemeral cloud storage - Store your reasoning state, large JSON structures, or any data to get a shareable URL. Perfect for: caching contexts before token limits, bridging multi-agent workflows, storing intermediate results, sharing data between sessions, or temporary data storage. Returns a shareable URL valid for 2 hours with auto-expiring data.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
agent_idYesYour agent identifier (e.g., "claude-coder", "gpt-researcher")
dataYesThe data to save - can be an object, array, or string
intentNoBrief description of why you are saving this data (helps with debugging and analytics)
ttl_secondsNoTime-to-live in seconds (max 7200 = 2 hours)

Implementation Reference

  • Handler logic for create_object tool, which uses createSharedWorkspace to communicate with the OPI API.
    if (name === 'create_object' || name === 'create_shared_workspace') {
      const { agent_id, data, intent, ttl_seconds = 7200 } = args;
    
      if (!agent_id || !data) {
        throw new Error('agent_id and data are required');
      }
    
      const result = await createSharedWorkspace(agent_id, data, intent, ttl_seconds);
    
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: true,
              object_id: result.workspace_id,
              url: result.url,
              expires_in: result.expires_in,
              message: `Object saved successfully. Share this URL: ${result.url}`
            }, null, 2)
          }
        ]
      };
    }
  • Definition and schema registration for the create_object tool.
    {
      name: 'create_object',
      description: 'Save objects to ephemeral cloud storage - Store your reasoning state, large JSON structures, or any data to get a shareable URL. Perfect for: caching contexts before token limits, bridging multi-agent workflows, storing intermediate results, sharing data between sessions, or temporary data storage. Returns a shareable URL valid for 2 hours with auto-expiring data.',
      inputSchema: {
        type: 'object',
        properties: {
          agent_id: {
            type: 'string',
            description: 'Your agent identifier (e.g., "claude-coder", "gpt-researcher")'
          },
          data: {
            description: 'The data to save - can be an object, array, or string'
          },
          intent: {
            type: 'string',
            description: 'Brief description of why you are saving this data (helps with debugging and analytics)'
          },
          ttl_seconds: {
            type: 'number',
            description: 'Time-to-live in seconds (max 7200 = 2 hours)',
            default: 7200
          }
        },
        required: ['agent_id', 'data']
      }
    },
  • Helper function createSharedWorkspace that performs the actual API request to save the object.
    async function createSharedWorkspace(agent_id, data, intent = null, ttl_seconds = 7200) {
      try {
        const payload = {
          agent_id,
          data,
          intent,
          ttl_seconds,
          payload_type: typeof data === 'string' ? 'text' : 'json'
        };
    
        const payloadSize = JSON.stringify(payload).length;
    
        const response = await axios.post(`${API_BASE_URL}/dump`, payload, {
          headers: {
            'Content-Type': 'application/json'
          },
          timeout: 10000
        });
    
        // Log successful workspace creation
        logEvent('workspace_created', {
          tool_name: 'create_shared_workspace',
          agent_id,
          workspace_id: response.data.workspace_id,
          workspace_url: response.data.url,
          payload_size: payloadSize,
          intent
        });
    
        return response.data;
      } catch (error) {
        // Log error
        logEvent('workspace_creation_failed', {
          tool_name: 'create_shared_workspace',
          agent_id,
          error: error.message,
          metadata: { stack: error.stack }
        });
    
        throw new Error(`Failed to create workspace: ${error.message}`);
      }
    }
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it's a write operation ('Save'), returns a shareable URL, has a time-to-live constraint ('valid for 2 hours', 'auto-expiring data'), and mentions use cases that imply it's for temporary storage. It doesn't cover rate limits or authentication needs, but provides substantial context beyond basic function.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and front-loaded: the first sentence states the core function, followed by specific use cases and behavioral details. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (a write operation with 4 parameters), no annotations, and no output schema, the description is largely complete: it covers purpose, usage, key behaviors (ephemeral storage, URL return), and complements the well-documented schema. However, it doesn't explicitly describe the return value format beyond 'shareable URL', which could be more detailed given the lack of output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the purpose of saving data ('Store your reasoning state, large JSON structures, or any data') and the outcome ('get a shareable URL'), which complements the schema's parameter descriptions. However, it doesn't provide additional details on parameter usage beyond what's in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Save objects to ephemeral cloud storage') and resource ('objects'), distinguishing it from the sibling tool 'get_object' which presumably retrieves rather than stores. It provides concrete examples of what can be stored ('reasoning state, large JSON structures, or any data') and the outcome ('get a shareable URL').

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly lists multiple scenarios for when to use this tool ('Perfect for: caching contexts before token limits, bridging multi-agent workflows, storing intermediate results, sharing data between sessions, or temporary data storage'), providing clear context. It also implies when not to use it by specifying the ephemeral nature ('auto-expiring data', 'valid for 2 hours'), suggesting alternatives for permanent storage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/dizzydes/0pi-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server