Conversations Overview - Noxus Documentation

What are Conversations?

Conversations in Noxus represent interactive chat sessions with AI models. They provide a structured way to build chatbots, virtual assistants, and other conversational AI applications with support for multiple AI models, custom tools, context management, and file handling. Conversation Flow

Key Features

Multi-Model Support

Choose from various AI models including GPT-4, Claude, and more

Tool Integration

Enhance conversations with web search, knowledge bases, and custom tools

Context Management

Maintain conversation history and context across multiple interactions

File Handling

Process and discuss documents, images, and other file types

Async Support

Build responsive applications with asynchronous operations

Customizable Settings

Fine-tune model parameters, temperature, tokens, and behavior

Core Concepts

Conversation Settings

Every conversation is configured with settings that control its behavior:

from noxus_sdk.resources.conversations import ConversationSettings

settings = ConversationSettings(
    model=["gpt-4o-mini"],           # AI model(s) to use
    temperature=0.7,                 # Creativity level (0.0-1.0)
    max_tokens=500,                  # Maximum response length
    tools=[],                        # Available tools
    extra_instructions="Be helpful"  # Additional instructions
)

Message Flow

Conversations follow a simple request-response pattern:

Create a conversation with specific settings
Send messages with text, files, or tool requests
Receive AI responses with generated content
Continue the conversation with follow-up messages

Basic Usage

Creating a Simple Conversation

from noxus_sdk.client import Client
from noxus_sdk.resources.conversations import ConversationSettings, MessageRequest

# Initialize client
client = Client(api_key="your_api_key_here")

# Configure conversation settings
settings = ConversationSettings(
    model=["gpt-4o-mini"],
    temperature=0.7,
    max_tokens=150,
    extra_instructions="You are a helpful assistant. Be concise and friendly."
)

# Create conversation
conversation = client.conversations.create(
    name="My Chat Assistant",
    settings=settings
)

print(f"Created conversation: {conversation.id}")

Sending Messages

# Send a simple text message
message = MessageRequest(content="Hello! How can you help me today?")
response = conversation.add_message(message)

print(f"AI Response: {response.message_parts}")

# Continue the conversation
follow_up = MessageRequest(content="Can you explain quantum computing in simple terms?")
response = conversation.add_message(follow_up)

print(f"AI Response: {response.message_parts}")

Working with Files

import base64

# Prepare file for upload
with open("document.pdf", "rb") as file:
    file_content = base64.b64encode(file.read()).decode("utf-8")

from noxus_sdk.resources.conversations import ConversationFile

# Create file object
conversation_file = ConversationFile(
    name="document.pdf",
    status="success",
    b64_content=file_content
)

# Send message with file
message = MessageRequest(
    content="Please summarize this document",
    files=[conversation_file]
)

response = conversation.add_message(message)
print(f"Document Summary: {response.message_parts}")

Conversation Tools

Tools extend conversation capabilities beyond basic text generation:

Available Tools

Web Research Tool

Enable AI to search the web for current information:

from noxus_sdk.resources.conversations import WebResearchTool

web_tool = WebResearchTool(
    enabled=True,
    extra_instructions="Focus on recent and reliable sources"
)

Knowledge Base Tools

Access your knowledge bases for specialized information:

from noxus_sdk.resources.conversations import KnowledgeBaseQaTool

kb_tool = KnowledgeBaseQaTool(
    enabled=True,
    kb_id="your_knowledge_base_id",
    extra_instructions="Provide detailed answers with citations"
)

Workflow Tools

Execute workflows from within conversations:

from noxus_sdk.resources.conversations import WorkflowTool

workflow_tool = WorkflowTool(
    enabled=True,
    workflow={
        "id": "workflow_id",
        "name": "Data Processor",
        "description": "Process and analyze data"
    }
)

Noxus Q&A Tool

Get help with Noxus platform features:

from noxus_sdk.resources.conversations import NoxusQaTool

noxus_tool = NoxusQaTool(
    enabled=True,
    extra_instructions="Explain features clearly with examples"
)

Using Tools in Conversations

from noxus_sdk.resources.conversations import (
    ConversationSettings,
    WebResearchTool,
    KnowledgeBaseQaTool
)

# Configure tools
web_research = WebResearchTool(
    enabled=True,
    extra_instructions="Focus on recent developments and reliable sources"
)

kb_tool = KnowledgeBaseQaTool(
    enabled=True,
    kb_id="company_kb_id",
    extra_instructions="Reference company policies and procedures"
)

# Create conversation with tools
settings = ConversationSettings(
    model=["gpt-4o-mini"],
    temperature=0.7,
    max_tokens=300,
    tools=[web_research, kb_tool],
    extra_instructions="Use tools when needed to provide accurate, up-to-date information"
)

conversation = client.conversations.create(
    name="Research Assistant",
    settings=settings
)

# Ask questions that trigger tool usage
message = MessageRequest(
    content="What are the latest developments in renewable energy technology?",
    tool="web_research"  # Explicitly request web research
)

response = conversation.add_message(message)
print(f"Research Results: {response.message_parts}")

Advanced Features

Asynchronous Operations

For high-performance applications:

import asyncio

async def async_conversation_example():
    client = Client(api_key="your_api_key_here")

    # Create conversation asynchronously
    settings = ConversationSettings(
        model=["gpt-4o-mini"],
        temperature=0.7,
        max_tokens=200
    )

    conversation = await client.conversations.acreate(
        name="Async Chat",
        settings=settings
    )

    # Send message asynchronously
    message = MessageRequest(content="Explain machine learning briefly")
    response = await conversation.aadd_message(message)

    return response.message_parts

# Run async conversation
result = asyncio.run(async_conversation_example())
print(result)

Conversation Management

# List all conversations
conversations = client.conversations.list(page=1, page_size=10)
for conv in conversations:
    print(f"Conversation: {conv.name} (ID: {conv.id})")

# Get specific conversation
conversation = client.conversations.get("conversation_id")

# Get conversation messages
messages = conversation.get_messages()
for msg in messages:
    print(f"Message: {msg.content[:50]}...")

# Update conversation settings
new_settings = ConversationSettings(
    model=["gpt-4o"],  # Upgrade to more powerful model
    temperature=0.5,
    max_tokens=400
)

updated_conversation = client.conversations.update(
    conversation_id=conversation.id,
    name="Updated Chat",
    settings=new_settings
)

# Delete conversation
client.conversations.delete(conversation_id=conversation.id)

Use Cases

Customer Support

Build intelligent support bots that can access knowledge bases and escalate to humans

Content Creation

Create writing assistants that help with blogs, marketing copy, and documentation

Research Assistant

Build tools that can search the web and analyze documents for insights

Educational Tutor

Create personalized learning experiences with adaptive questioning

Code Assistant

Build programming helpers that can explain code and suggest improvements

Data Analyst

Create assistants that can interpret data and generate reports

Conversation Patterns

Question-Answer Bot

# Simple Q&A bot with knowledge base
qa_settings = ConversationSettings(
    model=["gpt-4o-mini"],
    temperature=0.3,  # Lower temperature for factual responses
    tools=[KnowledgeBaseQaTool(
        enabled=True,
        kb_id="faq_kb_id",
        extra_instructions="Provide accurate answers based on the knowledge base"
    )],
    extra_instructions="You are a helpful FAQ bot. Always check the knowledge base first."
)

qa_bot = client.conversations.create(name="FAQ Bot", settings=qa_settings)

Research Assistant

# Research assistant with web access
research_settings = ConversationSettings(
    model=["gpt-4o"],
    temperature=0.4,
    tools=[
        WebResearchTool(
            enabled=True,
            extra_instructions="Use recent, authoritative sources"
        )
    ],
    extra_instructions="You are a research assistant. Always cite your sources and provide comprehensive answers."
)

research_assistant = client.conversations.create(
    name="Research Assistant",
    settings=research_settings
)

Multi-Tool Assistant

# Comprehensive assistant with multiple tools
multi_tool_settings = ConversationSettings(
    model=["gpt-4o"],
    temperature=0.6,
    tools=[
        WebResearchTool(enabled=True),
        KnowledgeBaseQaTool(
            enabled=True,
            kb_id="company_kb_id"
        ),
        WorkflowTool(
            enabled=True,
            workflow={
                "id": "data_analysis_workflow_id",
                "name": "Data Analyzer",
                "description": "Analyze datasets and generate insights"
            }
        )
    ],
    extra_instructions="You are a versatile assistant. Use the most appropriate tool for each request."
)

multi_assistant = client.conversations.create(
    name="Multi-Tool Assistant",
    settings=multi_tool_settings
)

Best Practices

Model Selection

Choose the right model for your use case:

gpt-4o-mini: Fast, cost-effective for simple tasks
gpt-4o: More capable for complex reasoning
claude-3-sonnet: Good balance of speed and capability

# For simple Q&A
settings = ConversationSettings(model=["gpt-4o-mini"])

# For complex analysis
settings = ConversationSettings(model=["gpt-4o"])

Temperature Settings

Adjust creativity based on your needs:

# Factual, consistent responses
settings = ConversationSettings(temperature=0.1)

# Balanced responses
settings = ConversationSettings(temperature=0.7)

# Creative responses
settings = ConversationSettings(temperature=0.9)

Context Management

Manage conversation length and context:

# Limit response length
settings = ConversationSettings(max_tokens=300)

# Provide clear instructions
settings = ConversationSettings(
    extra_instructions="Keep responses under 100 words. Be direct and helpful."
)

Error Handling

Implement robust error handling:

try:
    response = conversation.add_message(message)
    return response.message_parts
except Exception as e:
    print(f"Error in conversation: {e}")
    return "I'm sorry, I encountered an error. Please try again."

Performance Considerations

Response Time

Use faster models for simple tasks
Set appropriate max_tokens limits
Consider async operations for multiple conversations

Cost Optimization

Choose cost-effective models when possible
Limit token usage with max_tokens
Use tools strategically to reduce model calls

Context Length

Monitor conversation length
Implement context pruning for long conversations
Use summarization for context compression

Tool Usage

Enable only necessary tools
Provide clear tool instructions
Monitor tool usage and costs

Next Steps

Creating Conversations

Learn how to create and configure conversations

Messaging

Master message handling and conversation flow

Tools

Explore all available conversation tools

Examples

See real-world conversation implementations

Documentation Index

​What are Conversations?

​Key Features

Multi-Model Support

Tool Integration

Context Management

File Handling

Async Support

Customizable Settings

​Core Concepts

​Conversation Settings

​Message Flow

​Basic Usage

​Creating a Simple Conversation

​Sending Messages

​Working with Files

​Conversation Tools

​Available Tools

​Using Tools in Conversations

​Advanced Features

​Asynchronous Operations

​Conversation Management

​Use Cases

Customer Support

Content Creation

Research Assistant

Educational Tutor

Code Assistant

Data Analyst

​Conversation Patterns

​Question-Answer Bot

​Research Assistant

​Multi-Tool Assistant

​Best Practices

​Performance Considerations

Response Time

Cost Optimization

Context Length

Tool Usage

​Next Steps

Creating Conversations

Messaging

Tools

Examples

What are Conversations?

Key Features

Core Concepts

Conversation Settings

Message Flow

Basic Usage

Creating a Simple Conversation

Sending Messages

Working with Files

Conversation Tools

Available Tools

Using Tools in Conversations

Advanced Features

Asynchronous Operations

Conversation Management

Use Cases

Conversation Patterns

Question-Answer Bot

Research Assistant

Multi-Tool Assistant

Best Practices

Performance Considerations

Next Steps