Skip to main content

GeniSpace Agent Overview

GeniSpace agents are the core of the platform, powered by advanced large language models (LLMs) with long-term memory capabilities, chain-of-thought reasoning, and multimodal processing — enabling them to assist and automate your work in unprecedented ways.

Creation Process Overview (Aligned with Training Materials)​

When creating an agent in the Console, the basic process is as follows:

  1. Console → Agents → Create Agent
  2. Enter prompts: The system prompt defines the agent's role and behavior; prompt templates can define input/output formats
  3. Input schema and output schema: Task agents require JSON Schema-formatted input/output configuration
  4. Enable memory: Configure memory parameters to support multi-turn conversation context
  5. Test and debug: Verify agent behavior in the test area on the configuration page or in the Chat application

Conversational agents can be tested with multi-turn conversations in the Chat application.

Agent Types​

GeniSpace provides two different types of agents to serve different use cases:

Conversational Agent (CHAT)​

  • Continuous Dialogue: Supports multi-turn conversations, maintains context, and provides personalized responses
  • Memory Capabilities: Automatically remembers conversation history and understands long-term context
  • Personalized Experience: Configurable welcome messages and conversation styles
  • Use Cases: Customer service, consulting Q&A, creative collaboration

Task Agent (TASK)​

  • Structured Input/Output: Supports JSON Schema validation for data consistency
  • Strict Mode: Provides input/output validation and strict response formatting
  • Efficient Execution: Focused on executing specific tasks and delivering results
  • Use Cases: Data processing, API integration, automated workflows

Core Features​

Advanced Chain-of-Thought Reasoning​

GeniSpace agents are equipped with advanced chain-of-thought capabilities, giving you clear visibility into the AI's reasoning process:

  • Visualized Reasoning: Real-time display of the agent's thinking steps and decision-making process
  • Multi-Round Iteration: Supports step-by-step execution of complex tasks, with up to 15 reasoning iterations
  • Intelligent Task Planning: Automatically decomposes complex tasks into executable steps
  • Transparent Decision-Making: Each decision node includes detailed reasoning explanations

Multimodal Processing​

Agents support multiple content types for input and processing:

  • Text Processing: Natural language understanding and generation
  • Image Recognition: Supports image uploads and visual content analysis
  • Audio Processing: Understanding and processing of audio files
  • Mixed Content: Handles composite tasks involving text, images, and audio simultaneously

Intelligent Memory System​

Three memory isolation levels are supported, adapting to different use cases:

  • Session Isolation: Each conversation session has independent memory
  • User Isolation: Memory is shared across all sessions for the same user
  • Team Isolation: Memory is shared across all team members

Memory system parameters can be fine-tuned:

  • Maximum recent conversation messages (10–200)
  • Historical memory retrieval count (1–20)
  • Important turns count (3–50)

MCP Tool Ecosystem​

Agents integrate powerful tool invocation capabilities:

Built-in Tools​

  • HTML Content Rendering: Display rich text content directly in conversations
  • Chart Generation Tools: Create various data visualization charts
  • Table Display Tools: Present structured data in formatted tables
  • More Built-in Tools: Continuously expanding tool library

Platform Tools​

  • Operator Tools: Access platform-provided operators and user-defined custom operators
    • Supports all operators or specifying specific ones
    • View operator details, methods, and descriptions
    • Automatically distinguishes custom and system operators
  • Task Tools: Use platform tasks as callable tools
    • Supports all tasks or specifying specific ones
    • Access SCHEDULED, EVENT, MANUAL, and other task types
    • Agents can create and execute tasks
  • Data Source Tools: Use platform data sources as tools
    • Supports all data sources or specifying specific ones
    • Access READ, CREATE, UPDATE, DELETE, and other operation types
    • Agents can directly query and manipulate data sources
  • Flexible Configuration: Each tool type supports three selection strategies: "None", "All", and "Specified"

External MCP Servers​

  • Third-Party Integration: Connect to external MCP protocol-compatible services
  • Custom Tools: Integrate your own developed tools and services
  • API Key Management: Secure third-party service authentication

Display Plugin System​

Agents support a powerful display plugin system for customizing how tool output results are rendered:

Local Plugins​

  • Built-in Plugins: System-built-in plugins such as expense reimbursement, travel expenses, URL redirect, iframe embedding, etc.
  • Auto-Loading: No configuration needed — automatically available
  • Rich Functionality: Supports forms, charts, interactive components, and more

Remote Plugins​

  • Dynamic Loading: Dynamically load standalone plugin projects via HTTP URLs
  • Flexible Deployment: Supports GitHub Pages, CDN, self-hosted servers, enterprise intranets, and more
  • Independent Development: Plugins can be developed and deployed independently without redeploying the chat system
  • Version Management: Supports independent versioning and updates
  • Enterprise Customization: Enterprises can develop custom plugins with full control over UI and interactions

Plugin Features​

  • Auto-Discovery: Supports automatic plugin discovery and registration
  • Hot Reloading: Supports plugin hot-reload in development mode for improved development efficiency
  • Fallback Strategy: Automatically falls back to local plugins or default renderers if remote plugins fail to load
  • Security Controls: Supports plugin URL whitelisting for security

For detailed plugin development and usage guides, see Developer Resources (includes chat plugins).

Web Search Capabilities​

When chain-of-thought is enabled, agents can perform real-time web searches:

  • Real-Time Information Retrieval: Search for the latest web information and data
  • Search Controls: Configurable maximum search count (1–10) and results per search (1–20)
  • Intelligent Searching: Automatically constructs search queries based on conversation context

Knowledge Base Integration​

Agents can connect to your private knowledge bases:

  • Document Retrieval: Find relevant information from uploaded documents
  • Intelligent Matching: Semantic similarity-based matching for the most relevant content
  • Multi-Knowledge Base Support: Connect to multiple knowledge bases simultaneously

Associate a knowledge base in the agent configuration to enable RAG (Retrieval-Augmented Generation). See Knowledge Base Overview for details.

Agent Use Cases​

Intelligent Conversational Assistants​

  • Customer Service: 24/7 automatic responses to customer inquiries with complex requirement understanding
  • Consulting Advisor: Provide advice and recommendations based on domain expertise
  • Learning Partner: Assist with learning and research, answering professional questions
  • Creative Collaboration: Participate in brainstorming and provide creative ideas

Task Automation​

  • Data Processing: Extraction, transformation, and analysis of structured data
  • Document Generation: Automatically generate reports based on templates and data
  • API Integration: Act as a middleware layer for handling complex API calls
  • Workflow Coordination: Chain multiple tools and services to complete complex tasks

Content Creation​

  • Multimedia Content Analysis: Process mixed content including text, images, and audio
  • Intelligent Editing: Content rewriting, formatting, and optimization
  • Translation Services: Multilingual content understanding and conversion
  • Creative Generation: Generate creative content based on input materials

How Agents Work​

Chain-of-Thought Execution Flow​

  1. Input Understanding: The agent first analyzes the user's multimodal input
  2. Task Planning: Decomposes complex tasks into executable steps
  3. Tool Selection: Intelligently selects appropriate tools based on task requirements
  4. Iterative Execution: Executes tasks step by step, adjusting strategy in real time
  5. Result Consolidation: Aggregates results from each step to generate the final response

Memory Management Mechanism​

  • Recent Conversation Memory: Saves the complete context of the current session
  • Historical Memory Retrieval: Finds relevant historical interactions through vector search
  • Important Information Extraction: Automatically identifies and saves key information
  • Isolation Level Control: Manages memory scope according to the configured isolation level

Streaming Response Processing​

  • Real-Time Output: Thinks and outputs simultaneously — users see progress in real time
  • Thought Visualization: Displays the agent's reasoning steps and tool calls
  • Interruption and Resume: Supports user interruption and retry mechanisms
  • Error Handling: Intelligent retry and error recovery

How to Configure an Agent​

The GeniSpace platform provides flexible agent configuration options:

Basic Settings​

  1. Agent Type Selection: Choose between conversational or task agent
  2. Basic Information: Set the name, description, and tags
  3. Model Selection: Choose the most suitable AI model from multiple options
  4. Model Parameter Tuning: Configure temperature, maximum tokens, and other parameters

Advanced Configuration​

Chain-of-Thought Settings​

  • Enable Chain-of-Thought: Activate advanced reasoning and tool invocation capabilities
  • Maximum Iterations: Set the iteration limit for complex reasoning (5–50)
  • Task Planning: Enable intelligent task decomposition

Memory Configuration​

  • Memory Isolation Level: Choose session, user, or team-level memory isolation
  • Memory Recall Parameters:
    • Maximum recent conversation messages (10–200)
    • Historical memory retrieval count (1–20)
    • Important turns count (3–50)

Tool Configuration​

  • Built-in Tools: Enable HTML rendering, chart generation, and other built-in tools
  • Platform Tools: Configure access strategies for operators, tasks, and data sources
    • Operator Selection: None / All operators / Specified operators
    • Task Selection: None / All tasks / Specified tasks
    • Data Source Selection: None / All data sources / Specified data sources
  • External MCP Servers: Integrate third-party tools and services
  • Display Plugins: Configure rendering plugins for agent output results
    • Supports local and remote plugins
    • Remote plugins can be dynamically loaded via URL
    • Supports auto-discovery and hot reloading

Web Search (Requires Chain-of-Thought)​

  • Search Controls: Set the maximum number of searches (1–10)
  • Result Count: Configure the number of results per search (1–20)

Knowledge Base Integration​

  • Knowledge Base Selection: Connect relevant knowledge bases
  • Document Filtering: Select specific document collections

Task Agent-Specific Configuration​

  • Input Schema: Define JSON Schema-formatted input structure
  • Output Schema: Specify the expected output format and structure
  • Validation Settings: Enable input/output validation and strict mode

Agent Security & Privacy​

GeniSpace places a high priority on data security and privacy protection:

  • Data Encryption: All data processed by agents is end-to-end encrypted
  • Access Control: Role-based permission management ensures secure data access
  • Memory Isolation: Multi-level memory isolation mechanisms protect user data privacy
  • Tool Security: Security verification and monitoring for MCP tool invocations
  • Audit Logs: Complete records of agent operations and decision processes
  • Compliance: Meets major privacy regulations including GDPR and CCPA

API Integration​

GeniSpace provides flexible agent APIs supporting multiple integration methods:

Multimodal Chat API​

A chat interface supporting text, images, audio, and other content types:

const response = await fetch(`/developer/api-agents/${agentId}/chat`, {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    contents: [
      {
        type: "text",
        text: "Please analyze this image"
      },
      {
        type: "image_url",
        image_url: {
          url: "data:image/jpeg;base64,/9j/4AAQSkZ...",
          detail: "auto"
        }
      }
    ],
    session_id: "session_12345",
    stream: true,
    settings: {
      temperature: 0.7,
      max_tokens: 2000
    }
  })
});

Task Execution API​

For task agents with structured input/output:

const response = await fetch(`/developer/api-agents/${agentId}/execute`, {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    // Provide structured data according to the agent's input schema
    user_input: "Process this sales data",
    data_source: "sales_report_q3.csv",
    output_format: "summary_report",
    
    // Optional session and configuration
    session_id: "task_session_789",
    enable_memory: true,
    enable_thinking_chain: true
  })
});

Streaming Response Processing​

GeniSpace agents support real-time streaming responses, allowing you to receive the thinking process and results in real time:

// Handle streaming responses using Server-Sent Events
const eventSource = new EventSource(`/developer/api-agents/${agentId}/chat/stream`);

eventSource.onmessage = function(event) {
  const data = JSON.parse(event.data);
  
  switch(data.type) {
    case 'content_delta':
      // Incremental content update
      appendToMessage(data.content);
      break;
      
    case 'thinking':
      // Chain-of-thought step
      displayThinkingStep(data.step);
      break;
      
    case 'tool_call':
      // Tool call status
      updateToolStatus(data.tool_name, data.status);
      break;
      
    case 'complete':
      // Response complete
      finalizeMessage(data.final_content);
      eventSource.close();
      break;
  }
};

Session Management API​

Manage agent conversation sessions:

// Create a new session
const session = await fetch(`/developer/api-agents/${agentId}/sessions`, {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    title: "Data Analysis Session",
    sessionType: "chat"
  })
});

// Get session history
const history = await fetch(`/developer/api-agents/sessions/${sessionId}/messages`, {
  headers: {
    "Authorization": "Bearer YOUR_API_KEY"
  }
});

// Clear session memory
await fetch(`/developer/api-agents/${agentId}/memory/session/${sessionId}`, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY"
  },
  body: JSON.stringify({
    isolation_level: "session"
  })
});

API Feature Summary​

  • Multimodal Support: Simultaneously process text, images, audio, and other content
  • Streaming Responses: Receive the AI's thinking process and output in real time
  • Session Persistence: Automatically saves conversation history and context
  • Memory Management: Supports multi-level memory isolation and clearing
  • Chain-of-Thought Visualization: Provides detailed reasoning step information
  • Tool Call Tracking: Monitor tools used by the agent and their status

For detailed API documentation, see Agent API.

Getting Started with Agents​

Getting started with GeniSpace agents is straightforward:

Step 1: Create an Agent​

  1. Access the Agent Management Page: Navigate to the "Agents" section in the Console
  2. Select Agent Type: Choose conversational or task agent based on your needs
  3. Basic Configuration:
    • Set the agent name and description
    • Select an appropriate AI model
    • Add feature tags

Step 2: Advanced Configuration​

  1. Enable Chain-of-Thought: Activate advanced reasoning and tool invocation capabilities
  2. Configure the Memory System: Select memory isolation level and recall parameters
  3. Integrate Tools:
    • Enable built-in tools (charts, tables, HTML rendering)
    • Configure platform tools:
      • Select operators (all or specified)
      • Select tasks (all or specified)
      • Select data sources (all or specified)
    • Configure external MCP servers
    • Configure display plugins (local or remote)
  4. Knowledge Base Connection: Upload documents or connect existing knowledge bases
  5. Web Search Settings: Configure search parameters (optional)

Step 3: Test and Deploy​

  1. Functional Testing: Test agent functionality directly on the configuration page
  2. Conversation Testing: Validate agent responses through the chat interface
  3. API Integration: Obtain API keys and integrate into your applications
  4. Monitor and Optimize: Observe usage patterns and adjust configuration

Quick Start Templates​

We provide multiple pre-configured agent templates:

  • Customer Service Assistant: Configured with customer service knowledge bases and tools
  • Data Analyst: Integrated with data processing and visualization tools
  • Content Creator: Optimized for text generation and editing
  • Technical Consultant: Connected to technical documentation and problem-solving tools

Getting Help​

  • Documentation Center: View detailed configuration guides and best practices
  • API Documentation: Refer to the complete Agent API documentation
  • Community Support: Get help and share experiences in the user forum
  • Technical Support: Contact our technical team for professional support

Ready to explore more? Check out our Workflow Engine, Tool System, and API Reference to learn how to fully leverage GeniSpace's complete feature set.

Next Steps​

Explore more agent features:

Related guides: