Infactory is an AI data platform that allows you to turn your existing databases and data sources into intelligent, natural language-powered interfaces. It’s designed to help businesses extract valuable insights from their data without requiring complex SQL or database expertise.

The platform connects to your existing databases, automatically generates queries based on natural language questions, and provides tools for testing, deploying, and monitoring these queries in production applications.

Unlike traditional BI tools that typically require pre-built dashboards and reports, Infactory enables real-time, ad-hoc querying using natural language. Key differences include:

• Natural Language Interface: Users can ask questions in plain English instead of learning SQL or specialized query languages
• Auto-generated Queries: Infactory automatically generates appropriate database queries for natural language questions
• API-first Architecture: Easy integration with existing applications through REST APIs
• No Data Duplication: Connects directly to your existing databases without copying or moving data
• Adaptive Learning: Improves over time based on usage patterns and feedback

While traditional BI tools are focused on predefined analytics, Infactory enables conversational data access that can be embedded into any application.

No, Infactory does not store your actual data. It operates on a connection-based model, where it establishes secure connections to your existing databases. When queries are executed, data is processed temporarily but not persistently stored in Infactory.

Infactory does store metadata about your database schema, generated queries, and usage patterns to improve its performance and accuracy over time. This approach ensures that your sensitive data remains within your own database systems while still enabling intelligent query capabilities.

Infactory supports a wide range of SQL and NoSQL databases, including:

• PostgreSQL
• MySQL
• SQL Server
• Oracle
• SQLite
• MongoDB
• Snowflake
• BigQuery
• Redshift
• Databricks

We’re continuously adding support for additional databases. If you’re using a database that’s not listed here, please contact us to discuss integration possibilities.

Yes, Infactory is designed to integrate seamlessly with your existing applications through its API-first architecture. You can embed Infactory-powered data intelligence into web applications, mobile apps, chatbots, dashboards, or any other software that can make HTTP requests.

We provide SDKs for popular programming languages such as JavaScript, Python, and Java, as well as extensive API documentation to help you integrate Infactory with your existing technology stack.

The accuracy of Infactory’s auto-generated queries depends on several factors:

1. Database Schema: Well-designed database schemas with clear naming conventions and relationships produce more accurate queries
2. Question Clarity: Clearly formulated questions with specific intent yield better results
3. Training Examples: The more example questions and queries you provide, the more accurate the system becomes
4. Data Complexity: Simpler data models generally produce more accurate results initially

In most cases, Infactory achieves high accuracy rates, especially for common query patterns. For complex or domain-specific questions, you may need to review and refine the generated queries initially.

The platform includes tools for testing queries and providing feedback, which continuously improves accuracy over time. You can also create custom queries for specific question patterns to ensure 100% accuracy for critical use cases.

Infactory implements multiple layers of security to protect your data and connections:

• Connection Security: All database connections use encrypted channels and credentials are securely stored using industry-standard encryption
• API Authentication: API access requires authentication using API keys or OAuth tokens
• Role-Based Access: Granular permissions can be configured to control who can view, edit, and deploy queries
• Audit Logging: Comprehensive logs of all system access and actions
• No Data Storage: Your actual data remains in your databases and is not stored in Infactory
• Compliance: Built with GDPR, HIPAA, and other compliance frameworks in mind

Additionally, Infactory can be deployed in various configurations, including on-premises or within your private cloud environment for maximum security.

Yes, Infactory provides several ways to customize queries:

1. Manual Editing: You can directly edit the auto-generated queries in the platform’s interface
2. Custom Parameters: Define parameters to make queries more flexible and reusable
3. Templates: Create query templates for common patterns in your data
4. Output Formatting: Customize how query results are formatted and returned
5. Pre and Post Processing: Add custom code to run before or after query execution

These customization options give you full control over the query generation process while still benefiting from the natural language understanding capabilities of the platform.

Infactory analyzes your database schema to understand table relationships, foreign keys, and typical join patterns. It uses this understanding to automatically generate appropriate joins when questions require data from multiple tables.

For complex relationships that might not be explicitly defined in the schema (such as relationships across different databases or implicit relationships), you can provide additional metadata or custom queries to help Infactory understand these connections.

The platform also learns from usage patterns, so as users ask questions that require certain joins, Infactory improves its understanding of the relationships in your data model.

Infactory is designed to generate efficient queries that minimize database load:

1. Query Optimization: Generated queries include appropriate filtering and limiting to avoid excessive data retrieval
2. Connection Pooling: Efficient management of database connections to reduce overhead
3. Caching: Optional result caching to minimize redundant queries
4. Rate Limiting: Controls to prevent excessive query volume

For high-volume production environments, we recommend:

• Using read-only replicas for Infactory connections
• Implementing appropriate indexing on commonly queried fields
• Setting up monitoring to track query performance
• Utilizing the caching features for frequently asked questions

With these practices, most customers experience minimal performance impact on their database systems.

The setup time for Infactory varies depending on your database complexity and integration requirements:

• Basic Setup: Connecting to a database and generating initial queries can be done in minutes
• Basic Integration: Integrating with a simple application typically takes 1-2 days
• Enterprise Implementation: For complex enterprise environments with multiple databases and extensive security requirements, setup might take 1-2 weeks

Our onboarding team provides assistance throughout the setup process, and we offer professional services for complex implementations requiring customization or specialized integration work.

No, Infactory works with your existing database without requiring any modifications to your schema or structure. The platform adapts to your database rather than requiring you to adapt to it.

However, for optimal results, we recommend:

• Ensuring your database has appropriate indexes for commonly queried fields
• Having clear naming conventions for tables and columns
• Properly defined foreign key relationships (where applicable)

These are general database best practices and not specific requirements for using Infactory.

Infactory provides built-in monitoring and analytics tools that allow you to track:

• Query Volume: Number of queries processed over time
• Performance Metrics: Response times and resource usage
• Popular Questions: Most frequently asked questions
• Success Rates: Percentage of queries that return expected results
• Error Patterns: Common error types and their frequency

You can access these metrics through the Infactory dashboard or export them to your existing monitoring tools via our API. Custom alerts can also be configured to notify you about unusual patterns or performance issues.

Yes, Infactory can be used with sensitive and regulated data, provided appropriate security measures are implemented:

1. On-premises Deployment: For maximum security, Infactory can be deployed entirely within your own infrastructure
2. Access Controls: Granular permissions ensure only authorized users can access specific data
3. Audit Logging: Comprehensive activity logs for compliance and security monitoring
4. Data Filtering: Implement row-level security or data masking for sensitive fields
5. Compliance Features: GDPR, HIPAA, and other compliance capabilities are built into the platform

Many organizations in healthcare, finance, and government sectors use Infactory with sensitive data. We recommend consulting with your security and compliance teams to ensure your specific requirements are met.

Currently, Infactory supports English as its primary language for natural language queries. The platform can understand various phrasings, technical terms, and industry-specific terminology within English.

Support for additional languages is on our roadmap. If you have specific language requirements, please contact us to discuss your needs and timeline.

If Infactory is not interpreting your questions correctly, consider these common issues and solutions:

1. Question Clarity: Try rephrasing your question to be more specific about what you’re looking for
2. Domain-Specific Terms: Make sure any industry-specific or technical terms are properly explained or mapped in your settings
3. Schema Understanding: Check if your database schema is properly configured in Infactory, including table relationships
4. Missing Context: Some questions require context that might need to be explicitly provided
5. Training Examples: Add example questions and expected queries to help train the system

You can use the “Explore” page to test different phrasings and see how Infactory interprets them. For persistent issues, you can create custom queries for specific question patterns to ensure accurate results.

Authentication errors can occur for several reasons:

1. Expired API Key: Check if your API key is still valid and not expired
2. Incorrect Authentication: Ensure you’re using the correct authentication method (API key, OAuth token, etc.)
3. Missing Headers: Verify that you’re including the required authentication headers in your requests
4. Permission Issues: Your account might not have permission for the action you’re attempting
5. Network Problems: Firewalls or network configurations might be blocking authentication requests

Check your API key settings in the Infactory dashboard and ensure you’re following the authentication procedures outlined in our API documentation. If problems persist, you can regenerate your API key or contact support for assistance.

To improve query performance:

1. Optimize Database Indexes: Ensure appropriate indexes exist for commonly queried fields
2. Limit Result Sets: Modify queries to return only necessary data
3. Implement Caching: Use the caching features for frequently repeated queries
4. Query Optimization: Review the generated SQL for potential optimizations
5. Database Resources: Check if your database has sufficient resources
6. Connection Settings: Adjust connection pool settings for optimal performance

You can also refer to our Performance Optimization guide for detailed recommendations on improving query speed and efficiency.

If certain tables or columns are being ignored in queries:

1. Schema Visibility: Check if these tables/columns are properly visible in your Infactory schema
2. Question Specificity: Ensure your questions clearly indicate the need for that specific data
3. Relationship Configuration: Verify that table relationships are correctly defined
4. Column Aliases: Consider adding aliases or synonyms for columns with technical names
5. Usage Patterns: The system may need examples of how these tables/columns should be used

You can manually create queries that utilize these tables/columns to demonstrate the correct usage pattern to the system. Over time, Infactory will learn to incorporate them into auto-generated queries when appropriate.

For robust error handling in your Infactory integration:

1. Status Codes: Check HTTP status codes in API responses (2xx for success, 4xx for client errors, 5xx for server errors)
2. Error Messages: Parse the error message field in the response for specific information
3. Retry Logic: Implement appropriate retry mechanisms for transient errors
4. Fallback Options: Have fallback behavior for when the API is unavailable
5. Logging: Log errors with context for debugging

A simple error handling example in JavaScript:

async function queryInfactory(question) {
  try {
    const response = await fetch('https://api.yourdomain.com/query', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ question })
    });
    
    if (!response.ok) {
      const errorData = await response.json();
      console.error('Infactory API error:', errorData);
      
      // Handle specific error cases
      if (response.status === 401) {
        // Authentication error
        handleAuthError();
      } else if (response.status === 429) {
        // Rate limit exceeded
        return retryWithBackoff(question);
      } else {
        // Other errors
        throw new Error(`API error: ${errorData.message || response.statusText}`);
      }
    }
    
    return await response.json();
  } catch (error) {
    // Network or parsing errors
    console.error('Failed to query Infactory:', error);
    return useFallbackOption(question);
  }
}

For more detailed error handling strategies, refer to our Troubleshooting guide.

Infactory offers several pricing tiers to accommodate different usage levels:

1. Starter: For individuals and small teams starting to explore data intelligence
2. Professional: For growing businesses with moderate query volumes
3. Enterprise: For organizations with high query volumes and advanced security needs
4. Custom: Tailored solutions for specific requirements

Pricing is typically based on a combination of:

• Number of database connections
• Query volume
• Number of users
• Support level
• Deployment options (cloud vs. on-premises)

For specific pricing details and to get a quote tailored to your needs, please contact our sales team.

Yes, we offer a free trial of Infactory that allows you to:

• Connect to one database
• Test natural language querying
• Explore the query building interface
• Try basic deployment features

The trial typically lasts 14 days and includes access to our standard support channels. To start your free trial, sign up on our website.

Infactory offers multiple support channels:

1. Documentation: Comprehensive guides, tutorials, and API reference
2. Community Forum: Peer support and knowledge sharing
3. Email Support: Available on all paid plans
4. Chat Support: Real-time assistance for Professional and Enterprise plans
5. Dedicated Support Manager: Enterprise plans include a dedicated support contact
6. Professional Services: Custom implementation and integration assistance

Support availability and response times vary by plan level. Enterprise customers receive priority support with guaranteed response times.

Yes, we offer professional services to help with:

• Custom implementation and integration
• Database optimization for Infactory
• Query customization and templates
• Training and enablement
• Migration from other systems
• Custom feature development

Our professional services team consists of data engineers, integration specialists, and solution architects who can help ensure a successful implementation tailored to your specific needs.

Professional services are quoted separately from platform licenses. Contact us for details.

To stay informed about new features and updates:

1. Release Notes: Check our product release notes accessible from the dashboard
2. Email Updates: Subscribe to our product update newsletter
3. Blog: Follow our company blog for feature highlights and use cases
4. Webinars: Attend our regular product webinars
5. Community Forum: Join discussions on new features

Enterprise customers also receive regular update briefings from their account managers.

Yes, Infactory offers on-premises deployment options for organizations with specific security, compliance, or infrastructure requirements. On-premises deployment allows you to:

• Run Infactory entirely within your own infrastructure
• Maintain complete control over your data environment
• Meet stringent compliance requirements
• Integrate with internal systems not accessible from the cloud

On-premises deployments are typically available with Enterprise plans and include additional support for installation, configuration, and updates.

Integrating Infactory with frontend applications is straightforward using our REST API and client libraries. Here’s a basic approach:

1. Set Up API Access: Get your API key from the Infactory dashboard
2. Choose Integration Method:
   • Direct API calls from your backend
   • Client SDK for your frontend framework
   • Embedded components (for common use cases)
3. Implement User Interface: Design how users will ask questions and view results
4. Handle Responses: Process and display the data returned from Infactory
5. Error Handling: Implement appropriate error handling and fallbacks

For detailed integration steps, refer to our API Integration Guide and framework-specific examples:

• React Integration
• Vue Integration
• Angular Integration

Yes, Enterprise plans include white-labeling options that allow you to:

• Remove Infactory branding from user-facing elements
• Customize the look and feel to match your application
• Integrate seamlessly as if it were a native feature of your product
• Apply your own branding to generated visualizations and outputs

White-labeling is particularly valuable for SaaS companies, enterprises with internal applications, and organizations building customer-facing analytics tools.

For mission-critical applications requiring high availability:

1. Cloud Deployment: Our cloud service includes built-in redundancy across multiple availability zones
2. On-Premises HA: For on-premises deployments, we support clustering and load balancing
3. Disaster Recovery: Implementation of backup and failover procedures
4. SLA Options: Enterprise plans include availability SLAs with guaranteed uptime
5. Monitoring: Advanced monitoring and alerting for potential issues

Work with our solutions team to design an architecture that meets your specific availability requirements and recovery time objectives.

Yes, Infactory supports connecting to multiple databases simultaneously. This enables:

1. Cross-Database Queries: Generate insights that span multiple data sources
2. Unified Interface: Provide a single question interface across all your data
3. Consistent Access: Apply consistent security and governance across sources
4. Database Specialization: Use the right database for the right purpose

The platform handles the complexity of knowing which database to query based on the question context. You can also create custom queries that specifically join or aggregate data across multiple database connections when needed.