---
tags:
  - iso27DIY
  - architecture
  - SupaBase
  - LLMgenerated
---
To connect an LLM to Supabase and create content based on organizational data, you'll need to build a system that retrieves data, constructs prompts, and sends them to an LLM API. Here's how to approach this:

## 1. Set up Supabase Connection

First, establish a connection to your Supabase database:

```javascript
import { createClient } from '@supabase/supabase-js'

const supabaseUrl = 'your-supabase-url'
const supabaseKey = 'your-supabase-anon-key'
const supabase = createClient(supabaseUrl, supabaseKey)
```

## 2. Design Your Database Schema

Structure your tables to store:
- Organization data (name, industry, values, etc.)
- Prompt templates with placeholders
- Generated content history

```sql
-- Organizations table
CREATE TABLE organizations (
  id UUID PRIMARY KEY,
  name TEXT,
  industry TEXT,
  description TEXT,
  values JSONB,
  created_at TIMESTAMP DEFAULT NOW()
);

-- Prompt templates table
CREATE TABLE prompt_templates (
  id UUID PRIMARY KEY,
  name TEXT,
  template TEXT,
  variables JSONB,
  created_at TIMESTAMP DEFAULT NOW()
);
```

## 3. Create the Integration Logic

Build functions to retrieve data and construct prompts:

```javascript
// Fetch organization data
async function getOrganizationData(orgId) {
  const { data, error } = await supabase
    .from('organizations')
    .select('*')
    .eq('id', orgId)
    .single()
  
  if (error) throw error
  return data
}

// Fetch prompt template
async function getPromptTemplate(templateId) {
  const { data, error } = await supabase
    .from('prompt_templates')
    .select('*')
    .eq('id', templateId)
    .single()
  
  if (error) throw error
  return data
}

// Construct the final prompt
function constructPrompt(template, orgData) {
  let prompt = template.template
  
  // Replace placeholders with actual data
  prompt = prompt.replace('{{organization_name}}', orgData.name)
  prompt = prompt.replace('{{industry}}', orgData.industry)
  prompt = prompt.replace('{{description}}', orgData.description)
  
  // Handle JSON data
  if (orgData.values) {
    prompt = prompt.replace('{{values}}', JSON.stringify(orgData.values))
  }
  
  return prompt
}
```

## 4. Connect to Your LLM

Choose your LLM provider (OpenAI, Anthropic, etc.) and set up the API call:

```javascript
// Example with OpenAI
import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
})

async function generateContent(prompt) {
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: "You are a content creator for organizations."
      },
      {
        role: "user",
        content: prompt
      }
    ],
    max_tokens: 1000,
    temperature: 0.7
  })
  
  return response.choices[0].message.content
}
```

## 5. Create the Main Function

Tie everything together:

```javascript
async function createOrganizationContent(orgId, templateId) {
  try {
    // 1. Fetch organization data
    const orgData = await getOrganizationData(orgId)
    
    // 2. Fetch prompt template
    const template = await getPromptTemplate(templateId)
    
    // 3. Construct the prompt
    const finalPrompt = constructPrompt(template, orgData)
    
    // 4. Generate content with LLM
    const generatedContent = await generateContent(finalPrompt)
    
    // 5. Store the result back in Supabase
    const { data, error } = await supabase
      .from('generated_content')
      .insert({
        organization_id: orgId,
        template_id: templateId,
        content: generatedContent,
        created_at: new Date()
      })
    
    return generatedContent
    
  } catch (error) {
    console.error('Error generating content:', error)
    throw error
  }
}
```

## 6. Advanced Features

Consider adding:

**Dynamic prompt building**: Use more sophisticated template engines like Handlebars or Mustache for complex data insertion.

**Caching**: Store frequently used prompts and data to reduce database calls.

**Batch processing**: Process multiple organizations or content types simultaneously.

**Real-time updates**: Use Supabase's real-time features to trigger content generation when data changes.

**Error handling**: Implement robust error handling and retry logic for API calls.

## Example Usage

```javascript
// Generate marketing copy for a specific organization
const content = await createOrganizationContent(
  'org-uuid-123',
  'marketing-template-uuid-456'
)

console.log(content)
```

This architecture gives you flexibility to store various types of organizational data, create reusable prompt templates, and generate contextual content at scale. You can extend it by adding user authentication, content approval workflows, or integration with other services.