import { OpenAI } from 'langchain/llms/openai'
import { PromptTemplate } from 'langchain/prompts'
import { LLMChain } from 'langchain/chains'

const llm = new OpenAI({
  modelName: 'gpt-4o',
  temperature: 0.2,
})

const template = `
Analyze the following customer message and extract:
1. Primary intent (question, purchase, support, feedback)
2. Product categories mentioned
3. Sentiment (positive, negative, neutral)
4. Key entities

Customer message: {userMessage}

Response in JSON format:
`

const promptTemplate = new PromptTemplate({
  template,
  inputVariables: ['userMessage'],
})

const chain = new LLMChain({ llm, prompt: promptTemplate })
const result = await chain.call({ userMessage: 'I love your vanilla candles but would like something with more citrus notes.' })
console.log(result.text)

import { PineconeClient } from '@pinecone-database/pinecone'
import { OpenAIEmbeddings } from 'langchain/embeddings/openai'

// Initialize Pinecone
const pinecone = new PineconeClient()
await pinecone.init({
  apiKey: process.env.PINECONE_API_KEY,
  environment: process.env.PINECONE_ENVIRONMENT,
})
const index = pinecone.Index('fragrances')

// Generate embeddings for user preferences
const embeddings = new OpenAIEmbeddings()
const userPreferencesText = 'I prefer warm, spicy scents with vanilla and amber notes. Nothing too floral or sweet.'
const userEmbedding = await embeddings.embedQuery(userPreferencesText)

// Query for similar fragrances
const queryResponse = await index.query({
  vector: userEmbedding,
  topK: 5,
  includeMetadata: true
})

const recommendations = queryResponse.matches.map(match => match.metadata)
console.log('Recommended fragrances:', recommendations)

import { ChatOpenAI } from 'langchain/chat_models/openai'
import { HumanMessage, SystemMessage } from 'langchain/schema'

const chat = new ChatOpenAI({
  modelName: 'gpt-4o',
  temperature: 0.7,
})

// Get fragrance composition from database
const fragrance = {
  name: 'Midnight Amber',
  notes: {
    top: ['Bergamot', 'Orange'],
    middle: ['Jasmine', 'Rose'],
    base: ['Amber', 'Vanilla', 'Sandalwood']
  },
  intensity: 'moderate',
  family: 'Oriental'
}

const messages = [
  new SystemMessage(
    `You are an expert perfumer with decades of experience. 
    Describe how a fragrance would smell and evolve over time based on its composition.
    Include details about the initial impression, how it develops, and the lasting impression.
    Use sensory, evocative language that helps the reader imagine the scent experience.`
  ),
  new HumanMessage(
    `Create a virtual testing experience for this fragrance:
    Name: ${fragrance.name}
    Top notes: ${fragrance.notes.top.join(', ')}
    Middle notes: ${fragrance.notes.middle.join(', ')}
    Base notes: ${fragrance.notes.base.join(', ')}
    Intensity: ${fragrance.intensity}
    Family: ${fragrance.family}`
  ),
]

const response = await chat.call(messages)
console.log(response.content)

import { Claude } from 'langchain/llms/claude'
import { PromptTemplate } from 'langchain/prompts'
import { StructuredOutputParser } from 'langchain/output_parsers'

const llm = new Claude({
  modelName: 'claude-3-5-sonnet-20240229',
  temperature: 0.3,
})

// Define the structured output format
const parser = StructuredOutputParser.fromZodSchema(z.object({
  blendName: z.string().describe('A creative name for the custom fragrance blend'),
  baseFragrance: z.string().describe('The primary fragrance to use as a base'),
  additionalNotes: z.array(z.string()).describe('Additional fragrance notes to include'),
  proportions: z.record(z.number()).describe('Proportions of each component as percentages'),
  description: z.string().describe('A marketing description of the final blend'),
  useCases: z.array(z.string()).describe('Recommended use cases for this blend')
}))

const formatInstructions = parser.getFormatInstructions()

const template = `
You are an expert perfumer creating a custom fragrance blend.

User preferences:
- Preferred scent families: {preferredFamilies}
- Favorite notes: {favoriteNotes}
- Dislikes: {dislikedNotes}
- Occasion: {occasion}
- Mood desired: {desiredMood}

Create a custom fragrance blend based on these preferences.
${formatInstructions}
`

const promptTemplate = new PromptTemplate({
  template,
  inputVariables: ['preferredFamilies', 'favoriteNotes', 'dislikedNotes', 'occasion', 'desiredMood'],
  partialVariables: { format_instructions: formatInstructions }
})

const input = {
  preferredFamilies: 'Woody, Oriental',
  favoriteNotes: 'Sandalwood, Vanilla, Amber',
  dislikedNotes: 'Overly floral, Powdery',
  occasion: 'Evening events',
  desiredMood: 'Warm and sophisticated'
}

const prompt = await promptTemplate.format(input)
const result = await llm.call(prompt)
const parsedResult = await parser.parse(result)

console.log('Custom Blend:', parsedResult)

import { RetrievalQAChain } from 'langchain/chains'
import { ChatOpenAI } from 'langchain/chat_models/openai'
import { SupabaseVectorStore } from 'langchain/vectorstores/supabase'
import { OpenAIEmbeddings } from 'langchain/embeddings/openai'
import { supabase } from '../lib/supabaseClient'

// Initialize the LLM
const model = new ChatOpenAI({
  modelName: 'gpt-4o',
  temperature: 0.2,
})

// Initialize the vector store
const embeddings = new OpenAIEmbeddings()
const vectorStore = new SupabaseVectorStore(embeddings, {
  client: supabase,
  tableName: 'support_documents',
  queryName: 'match_documents',
})

// Create a retriever
const retriever = vectorStore.asRetriever({
  searchKwargs: { k: 5 },
})

// Create the chain
const chain = RetrievalQAChain.fromLLM(model, retriever, {
  returnSourceDocuments: true,
})

// Handle a customer support inquiry
async function handleSupportInquiry(question: string, userId: string) {
  // Get user context from database
  const { data: userData } = await supabase
    .from('profiles')
    .select('*, orders(*)')
    .eq('id', userId)
    .single()
  
  // Append user context to the question
  const contextualizedQuestion = `
    Question: ${question}
    
    User Context:
    - Name: ${userData.full_name}
    - Member since: ${userData.member_since}
    - Recent orders: ${userData.orders.map(order => order.id).join(', ')}
  `
  
  const response = await chain.call({
    query: contextualizedQuestion,
  })
  
  return {
    answer: response.text,
    sources: response.sourceDocuments.map(doc => doc.metadata.source),
  }
}

const result = await handleSupportInquiry(
  'When will my order #MNKY-12345 arrive?', 
  'user-123'
)
console.log(result)

import { Pipeline } from '@huggingface/inference'
import { OpenAI } from 'langchain/llms/openai'

// Initialize the models
const hfPipeline = new Pipeline(process.env.HF_API_KEY)
const llm = new OpenAI({
  modelName: 'gpt-4o',
  temperature: 0.3,
})

// Analyze user text for emotional indicators
async function analyzeMood(userText: string) {
  // Use Hugging Face for sentiment analysis
  const sentimentResult = await hfPipeline.sentiment({
    model: 'distilbert-base-uncased-finetuned-sst-2-english',
    inputs: userText,
  })
  
  // Use emotion detection model
  const emotionResult = await hfPipeline.classification({
    model: 'SamLowe/roberta-base-go_emotions',
    inputs: userText,
  })
  
  return {
    sentiment: sentimentResult,
    emotions: emotionResult,
  }
}

// Generate product recommendations based on mood
async function getMoodBasedRecommendations(moodAnalysis: any) {
  const prompt = `
    Based on the following mood analysis, recommend 3 MOOD MNKY products
    that would help enhance or complement the user's current emotional state.
    
    Sentiment: ${moodAnalysis.sentiment.label} (${moodAnalysis.sentiment.score})
    Primary emotions: ${moodAnalysis.emotions.slice(0, 3).map(e => `${e.label} (${e.score})`).join(', ')}
    
    For each product:
    1. Name and category
    2. Key fragrance notes
    3. Why it's appropriate for this mood
    4. How it might benefit the user
    
    Format as a JSON array.
  `
  
  const result = await llm.call(prompt)
  return JSON.parse(result)
}

// Example usage
const userJournal = "I've been feeling overwhelmed with work lately, but today I finally completed a big project. I'm relieved but still feeling a bit anxious about the next steps."

const moodAnalysis = await analyzeMood(userJournal)
const recommendations = await getMoodBasedRecommendations(moodAnalysis)

console.log('Mood Analysis:', moodAnalysis)
console.log('Recommended Products:', recommendations)