import json
import os
import boto3
import openai
from aws_lambda_powertools import Logger, Tracer, Metrics
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext

# Initialize utilities
logger = Logger()
tracer = Tracer()
metrics = Metrics()
app = APIGatewayRestResolver()

# Initialize DynamoDB
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ.get('CONVERSATION_HISTORY_TABLE'))

# Initialize OpenAI client
openai.api_key = os.environ.get('OPENAI_API_KEY')

@app.post("/chat")
@tracer.capture_method
def chat():
    try:
        # Parse request
        request_body = app.current_event.body
        body = json.loads(request_body)
        user_id = body.get('user_id')
        message = body.get('message')
        
        # Get conversation history
        history = get_conversation_history(user_id)
        
        # Prepare messages for OpenAI
        messages = [
            {"role": "system", "content": "You are Word Up! Bot, a helpful assistant that specializes in cloud technologies."}
        ]
        
        # Add conversation history
        for msg in history:
            messages.append(msg)
        
        # Add the current message
        messages.append({"role": "user", "content": message})
        
        # Call OpenAI
        response = openai.ChatCompletion.create(
            model="gpt-4-turbo",
            messages=messages,
            temperature=0.7,
            max_tokens=1000
        )
        
        # Extract assistant's reply
        assistant_message = response['choices'][0]['message']['content']
        
        # Store the conversation
        store_message(user_id, "user", message)
        store_message(user_id, "assistant", assistant_message)
        
        # Return response
        return {
            "statusCode": 200,
            "body": json.dumps({
                "message": assistant_message
            })
        }
    except Exception as e:
        logger.exception("Error processing request")
        return {
            "statusCode": 500,
            "body": json.dumps({
                "error": str(e)
            })
        }

def get_conversation_history(user_id, limit=10):
    response = table.query(
        KeyConditionExpression=boto3.dynamodb.conditions.Key('user_id').eq(user_id),
        Limit=limit * 2,  # Multiply by 2 because we store user and assistant messages separately
        ScanIndexForward=False  # Get most recent messages first
    )
    
    # Sort by timestamp
    messages = sorted(response.get('Items', []), key=lambda x: x['timestamp'])
    
    # Format for OpenAI API
    return [{"role": msg['role'], "content": msg['content']} for msg in messages]

def store_message(user_id, role, content):
    table.put_item(
        Item={
            'user_id': user_id,
            'message_id': f"{user_id}_{int(datetime.now().timestamp())}",
            'role': role,
            'content': content,
            'timestamp': datetime.now().isoformat()
        }
    )

@logger.inject_lambda_context
@tracer.capture_lambda_handler
@metrics.log_metrics
def lambda_handler(event, context: LambdaContext):
    return app.resolve(event, context)

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Word Up! Bot - OpenAI GPT Integration'

Parameters:
  OpenAIApiKey:
    Type: String
    NoEcho: true
    Description: Your OpenAI API Key

Resources:
  # DynamoDB Table for conversation history
  ConversationHistoryTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: WordUpBotConversations
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: user_id
          AttributeType: S
        - AttributeName: message_id
          AttributeType: S
      KeySchema:
        - AttributeName: user_id
          KeyType: HASH
        - AttributeName: message_id
          KeyType: RANGE
      TimeToLiveSpecification:
        AttributeName: ttl
        Enabled: true

  # Lambda execution role
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DynamoDBAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - dynamodb:Query
                  - dynamodb:PutItem
                Resource: !GetAtt ConversationHistoryTable.Arn

  # Lambda function
  WordUpBotFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: WordUpBotFunction
      Runtime: python3.9
      Handler: app.lambda_handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Timeout: 30
      MemorySize: 256
      Environment:
        Variables:
          OPENAI_API_KEY: !Ref OpenAIApiKey
          CONVERSATION_HISTORY_TABLE: !Ref ConversationHistoryTable
      Code:
        ZipFile: |
          # Lambda function code would be deployed separately, not inline
          def lambda_handler(event, context):
              return {"statusCode": 200, "body": "Function placeholder"}

  # API Gateway REST API
  WordUpBotApi:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: WordUpBotApi
      Description: API for Word Up! Bot

  # API Gateway resource
  ChatResource:
    Type: AWS::ApiGateway::Resource
    Properties:
      RestApiId: !Ref WordUpBotApi
      ParentId: !GetAtt WordUpBotApi.RootResourceId
      PathPart: chat

  # API Gateway method
  ChatMethod:
    Type: AWS::ApiGateway::Method
    Properties:
      RestApiId: !Ref WordUpBotApi
      ResourceId: !Ref ChatResource
      HttpMethod: POST
      AuthorizationType: NONE
      Integration:
        Type: AWS_PROXY
        IntegrationHttpMethod: POST
        Uri: !Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${WordUpBotFunction.Arn}/invocations

  # API Gateway deployment
  ApiDeployment:
    Type: AWS::ApiGateway::Deployment
    DependsOn: ChatMethod
    Properties:
      RestApiId: !Ref WordUpBotApi
      StageName: prod

  # Lambda permission for API Gateway
  ApiGatewayInvokeLambdaPermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref WordUpBotFunction
      Action: lambda:InvokeFunction
      Principal: apigateway.amazonaws.com
      SourceArn: !Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${WordUpBotApi}/*/POST/chat

Outputs:
  ApiEndpoint:
    Description: API Endpoint URL
    Value: !Sub https://${WordUpBotApi}.execute-api.${AWS::Region}.amazonaws.com/prod/chat
  DynamoDBTableName:
    Description: DynamoDB Table Name
    Value: !Ref ConversationHistoryTable

import os
import json
import functions_framework
from google.cloud import firestore
import openai
import datetime

# Initialize Firestore client
db = firestore.Client()

# Initialize OpenAI client
openai.api_key = os.environ.get('OPENAI_API_KEY')

@functions_framework.http
def word_up_bot(request):
    """
    HTTP Cloud Function to interact with OpenAI's GPT.
    """
    # Set CORS headers for preflight requests
    if request.method == 'OPTIONS':
        headers = {
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'POST',
            'Access-Control-Allow-Headers': 'Content-Type',
            'Access-Control-Max-Age': '3600'
        }
        return ('', 204, headers)

    # Set CORS headers for main request
    headers = {
        'Access-Control-Allow-Origin': '*'
    }

    try:
        # Parse request data
        request_json = request.get_json(silent=True)
        
        if not request_json:
            return (json.dumps({'error': 'No request data provided'}), 400, headers)
        
        user_id = request_json.get('user_id')
        message = request_json.get('message')
        
        if not user_id or not message:
            return (json.dumps({'error': 'Missing required fields: user_id and message'}), 400, headers)
        
        # Get conversation history
        history = get_conversation_history(user_id)
        
        # Prepare messages for OpenAI
        messages = [
            {"role": "system", "content": "You are Word Up! Bot, a helpful assistant that specializes in cloud technologies."}
        ]
        
        # Add conversation history
        for msg in history:
            messages.append(msg)
        
        # Add the current message
        messages.append({"role": "user", "content": message})
        
        # Call OpenAI
        response = openai.ChatCompletion.create(
            model="gpt-4-turbo",
            messages=messages,
            temperature=0.7,
            max_tokens=1000
        )
        
        # Extract assistant's reply
        assistant_message = response['choices'][0]['message']['content']
        
        # Store the conversation
        store_message(user_id, "user", message)
        store_message(user_id, "assistant", assistant_message)
        
        # Return response
        return (json.dumps({'message': assistant_message}), 200, headers)
    
    except Exception as e:
        print(f"Error: {str(e)}")
        return (json.dumps({'error': str(e)}), 500, headers)

def get_conversation_history(user_id, limit=10):
    """
    Retrieve conversation history from Firestore.
    """
    # Reference to the conversation collection
    conversations_ref = db.collection('conversations')
    
    # Query messages for this user, ordered by timestamp
    query = conversations_ref.where('user_id', '==', user_id).order_by('timestamp').limit(limit * 2)
    
    # Execute query and format messages for OpenAI API
    messages = []
    for doc in query.stream():
        data = doc.to_dict()
        messages.append({"role": data['role'], "content": data['content']})
    
    return messages

def store_message(user_id, role, content):
    """
    Store a message in Firestore.
    """
    # Reference to the conversation collection
    conversations_ref = db.collection('conversations')
    
    # Prepare document data
    now = datetime.datetime.now()
    message_data = {
        'user_id': user_id,
        'role': role,
        'content': content,
        'timestamp': now,
        'ttl': now + datetime.timedelta(days=30)  # TTL for message deletion after 30 days
    }
    
    # Add document to collection
    conversations_ref.add(message_data)

provider "google" {
  project = var.project_id
  region  = var.region
}

# Variables
variable "project_id" {
  description = "GCP Project ID"
  type        = string
}

variable "region" {
  description = "GCP Region"
  default     = "us-central1"
}

variable "openai_api_key" {
  description = "OpenAI API Key"
  type        = string
  sensitive   = true
}

# Enable required APIs
resource "google_project_service" "cloudfunctions" {
  project = var.project_id
  service = "cloudfunctions.googleapis.com"
}

resource "google_project_service" "firestore" {
  project = var.project_id
  service = "firestore.googleapis.com"
}

resource "google_project_service" "cloudbuild" {
  project = var.project_id
  service = "cloudbuild.googleapis.com"
}

# Create a storage bucket for Cloud Function code
resource "google_storage_bucket" "function_bucket" {
  name     = "${var.project_id}-word-up-bot-function"
  location = var.region
  uniform_bucket_level_access = true
}

# Create a ZIP archive of Cloud Function code
data "archive_file" "function_zip" {
  type        = "zip"
  output_path = "function-source.zip"
  source_dir  = "function-source"  # Directory containing your function code
}

# Upload the Cloud Function code to the bucket
resource "google_storage_bucket_object" "function_code" {
  name   = "function-source-${data.archive_file.function_zip.output_md5}.zip"
  bucket = google_storage_bucket.function_bucket.name
  source = data.archive_file.function_zip.output_path
}

# Create the Cloud Function
resource "google_cloudfunctions_function" "word_up_bot" {
  name        = "word-up-bot"
  description = "Word Up! Bot - OpenAI GPT Integration"
  runtime     = "python39"

  available_memory_mb   = 256
  source_archive_bucket = google_storage_bucket.function_bucket.name
  source_archive_object = google_storage_bucket_object.function_code.name
  trigger_http          = true
  entry_point           = "word_up_bot"
  
  environment_variables = {
    OPENAI_API_KEY = var.openai_api_key
  }

  depends_on = [
    google_project_service.cloudfunctions,
    google_project_service.cloudbuild
  ]
}

# IAM entry for all users to invoke the function
resource "google_cloudfunctions_function_iam_member" "invoker" {
  project        = var.project_id
  region         = var.region
  cloud_function = google_cloudfunctions_function.word_up_bot.name
  role           = "roles/cloudfunctions.invoker"
  member         = "allUsers"
}

# Output the Cloud Function URL
output "function_url" {
  value = google_cloudfunctions_function.word_up_bot.https_trigger_url
}

using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Azure.Data.Tables;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;

namespace WordUpBot.Function
{
    public static class WordUpBotFunction
    {
        private static readonly HttpClient httpClient = new HttpClient();
        private static readonly string OpenAIApiKey = Environment.GetEnvironmentVariable("OpenAIApiKey");
        private static readonly string TableConnectionString = Environment.GetEnvironmentVariable("TableConnectionString");
        private static readonly string TableName = "ConversationHistory";

        [FunctionName("WordUpBot")]
        public static async Task Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            log.LogInformation("Word Up! Bot function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var data = JsonConvert.DeserializeObject(requestBody);

            if (data == null || string.IsNullOrEmpty(data.UserId) || string.IsNullOrEmpty(data.Message))
            {
                return new BadRequestObjectResult("Please pass a valid request with UserId and Message in the request body");
            }

            try
            {
                // Get conversation history
                var history = await GetConversationHistoryAsync(data.UserId);

                // Prepare messages for OpenAI
                var messages = new List
                {
                    new Message { Role = "system", Content = "You are Word Up! Bot, a helpful assistant that specializes in cloud technologies." }
                };

                // Add conversation history
                messages.AddRange(history);

                // Add the current message
                messages.Add(new Message { Role = "user", Content = data.Message });

                // Call OpenAI
                var openAiResponse = await CallOpenAIAsync(messages);

                if (openAiResponse == null)
                {
                    return new StatusCodeResult(StatusCodes.Status500InternalServerError);
                }

                // Store messages
                await StoreMessageAsync(data.UserId, "user", data.Message);
                await StoreMessageAsync(data.UserId, "assistant", openAiResponse);

                return new OkObjectResult(new { message = openAiResponse });
            }
            catch (Exception ex)
            {
                log.LogError($"Error: {ex.Message}");
                return new StatusCodeResult(StatusCodes.Status500InternalServerError);
            }
        }

        private static async Task> GetConversationHistoryAsync(string userId)
        {
            // Create table client
            var tableClient = new TableClient(TableConnectionString, TableName);
            await tableClient.CreateIfNotExistsAsync();

            // Query messages for this user
            var query = tableClient.QueryAsync(filter: $"PartitionKey eq '{userId}'");

            var messages = new List();
            await foreach (var entity in query)
            {
                messages.Add(new Message
                {
                    Role = entity.Role,
                    Content = entity.Content
                });
            }

            // Order by timestamp and take the last 10 messages
            return messages.OrderBy(m => m.Timestamp).TakeLast(10).ToList();
        }

        private static async Task StoreMessageAsync(string userId, string role, string content)
        {
            // Create table client
            var tableClient = new TableClient(TableConnectionString, TableName);
            await tableClient.CreateIfNotExistsAsync();

            // Create entity
            var entity = new ConversationEntity
            {
                PartitionKey = userId,
                RowKey = Guid.NewGuid().ToString(),
                Role = role,
                Content = content,
                Timestamp = DateTime.UtcNow
            };

            // Add entity to table
            await tableClient.AddEntityAsync(entity);
        }

        private static async Task CallOpenAIAsync(List messages)
        {
            // Set up the request to OpenAI
            var requestData = new
            {
                model = "gpt-4-turbo",
                messages = messages.Select(m => new { role = m.Role, content = m.Content }).ToArray(),
                temperature = 0.7,
                max_tokens = 1000
            };

            var content = new StringContent(JsonConvert.SerializeObject(requestData), Encoding.UTF8, "application/json");
            httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", OpenAIApiKey);

            var response = await httpClient.PostAsync("https://api.openai.com/v1/chat/completions", content);
            
            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            var responseString = await response.Content.ReadAsStringAsync();
            var responseObject = JsonConvert.DeserializeObject(responseString);

            return responseObject.choices[0].message.content.ToString();
        }

        public class RequestData
        {
            public string UserId { get; set; }
            public string Message { get; set; }
        }

        public class Message
        {
            public string Role { get; set; }
            public string Content { get; set; }
            public DateTime Timestamp { get; set; } = DateTime.UtcNow;
        }

        public class ConversationEntity : Azure.Data.Tables.ITableEntity
        {
            public string PartitionKey { get; set; }
            public string RowKey { get; set; }
            public DateTimeOffset? Timestamp { get; set; }
            public ETag ETag { get; set; }
            public string Role { get; set; }
            public string Content { get; set; }
        }
    }
}

@description('Location for all resources.')
param location string = resourceGroup().location

@description('The name of the function app.')
param functionAppName string = 'wordupbot-${uniqueString(resourceGroup().id)}'

@description('Storage Account type')
@allowed([
  'Standard_LRS'
  'Standard_GRS'
  'Standard_RAGRS'
])
param storageAccountType string = 'Standard_LRS'

@description('OpenAI API Key')
@secure()
param openAIApiKey string

// Storage Account
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-08-01' = {
  name: 'stwordupbot${uniqueString(resourceGroup().id)}'
  location: location
  kind: 'StorageV2'
  sku: {
    name: storageAccountType
  }
  properties: {
    supportsHttpsTrafficOnly: true
    minimumTlsVersion: 'TLS1_2'
  }
}

// Storage Account - Tables
resource tableService 'Microsoft.Storage/storageAccounts/tableServices@2021-08-01' = {
  name: 'default'
  parent: storageAccount
}

// Table for conversation history
resource conversationTable 'Microsoft.Storage/storageAccounts/tableServices/tables@2021-08-01' = {
  name: 'ConversationHistory'
  parent: tableService
}

// App Service Plan (Consumption)
resource appServicePlan 'Microsoft.Web/serverfarms@2021-03-01' = {
  name: 'plan-${functionAppName}'
  location: location
  sku: {
    name: 'Y1'
    tier: 'Dynamic'
  }
  properties: {}
}

// Function App
resource functionApp 'Microsoft.Web/sites@2021-03-01' = {
  name: functionAppName
  location: location
  kind: 'functionapp'
  properties: {
    serverFarmId: appServicePlan.id
    siteConfig: {
      appSettings: [
        {
          name: 'AzureWebJobsStorage'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
        {
          name: 'WEBSITE_CONTENTSHARE'
          value: toLower(functionAppName)
        }
        {
          name: 'FUNCTIONS_EXTENSION_VERSION'
          value: '~4'
        }
        {
          name: 'FUNCTIONS_WORKER_RUNTIME'
          value: 'dotnet'
        }
        {
          name: 'OpenAIApiKey'
          value: openAIApiKey
        }
        {
          name: 'TableConnectionString'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
      ]
      ftpsState: 'Disabled'
      minTlsVersion: '1.2'
    }
    httpsOnly: true
  }
}

// Application Insights
resource applicationInsights 'Microsoft.Insights/components@2020-02-02' = {
  name: 'ai-${functionAppName}'
  location: location
  kind: 'web'
  properties: {
    Application_Type: 'web'
    Request_Source: 'rest'
  }
}

// Output the function app URL
output functionAppUrl string = 'https://${functionApp.properties.defaultHostName}/api/WordUpBot'

FROM python:3.9-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY app.py .
COPY .env .

# Set environment variables
ENV PYTHONUNBUFFERED=1

# Expose port
EXPOSE 8080

# Run the application
CMD ["python", "app.py"]

import os
from flask import Flask, request, jsonify
from flask_cors import CORS
import openai
import sqlite3
import datetime
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize Flask app
app = Flask(__name__)
CORS(app)

# Initialize OpenAI client
openai.api_key = os.getenv('OPENAI_API_KEY')

# Initialize SQLite database
def init_db():
    conn = sqlite3.connect('conversations.db')
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS conversations (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        user_id TEXT NOT NULL,
        role TEXT NOT NULL,
        content TEXT NOT NULL,
        timestamp TEXT NOT NULL
    )
    ''')
    conn.commit()
    conn.close()

init_db()

@app.route('/chat', methods=['POST'])
def chat():
    try:
        # Parse request data
        data = request.get_json()
        
        if not data:
            return jsonify({'error': 'No request data provided'}), 400
        
        user_id = data.get('user_id')
        message = data.get('message')
        
        if not user_id or not message:
            return jsonify({'error': 'Missing required fields: user_id and message'}), 400
        
        # Get conversation history
        history = get_conversation_history(user_id)
        
        # Prepare messages for OpenAI
        messages = [
            {"role": "system", "content": "You are Word Up! Bot, a helpful assistant that specializes in cloud technologies."}
        ]
        
        # Add conversation history
        for msg in history:
            messages.append(msg)
        
        # Add the current message
        messages.append({"role": "user", "content": message})
        
        # Call OpenAI
        response = openai.ChatCompletion.create(
            model="gpt-4-turbo",
            messages=messages,
            temperature=0.7,
            max_tokens=1000
        )
        
        # Extract assistant's reply
        assistant_message = response['choices'][0]['message']['content']
        
        # Store the conversation
        store_message(user_id, "user", message)
        store_message(user_id, "assistant", assistant_message)
        
        # Return response
        return jsonify({'message': assistant_message})
    
    except Exception as e:
        print(f"Error: {str(e)}")
        return jsonify({'error': str(e)}), 500

def get_conversation_history(user_id, limit=10):
    """
    Retrieve conversation history from SQLite.
    """
    conn = sqlite3.connect('conversations.db')
    cursor = conn.cursor()
    
    cursor.execute(
        "SELECT role, content FROM conversations WHERE user_id = ? ORDER BY timestamp LIMIT ?", 
        (user_id, limit * 2)
    )
    
    results = cursor.fetchall()
    conn.close()
    
    messages = []
    for role, content in results:
        messages.append({"role": role, "content": content})
    
    return messages

def store_message(user_id, role, content):
    """
    Store a message in SQLite.
    """
    conn = sqlite3.connect('conversations.db')
    cursor = conn.cursor()
    
    now = datetime.datetime.now().isoformat()
    cursor.execute(
        "INSERT INTO conversations (user_id, role, content, timestamp) VALUES (?, ?, ?, ?)",
        (user_id, role, content, now)
    )
    
    conn.commit()
    conn.close()

if __name__ == '__main__':
    # Create database if it doesn't exist
    init_db()
    
    # Run the app
    port = int(os.getenv('PORT', 8080))
    app.run(host='0.0.0.0', port=port)

version: '3'

services:
  word-up-bot:
    build: .
    ports:
      - "8080:8080"
    volumes:
      - ./data:/app/data
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    restart: unless-stopped

flask==2.3.3
flask-cors==4.0.0
openai==1.3.5
python-dotenv==1.0.0
gunicorn==21.2.0

import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.document_loaders import DirectoryLoader, TextLoader
import openai

# Load documents (cloud service documentation)
loader = DirectoryLoader('./cloud_docs/', glob="**/*.md", loader_cls=TextLoader)
documents = loader.load()

# Split documents into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
texts = text_splitter.split_documents(documents)

# Initialize embeddings
embeddings = OpenAIEmbeddings(openai_api_key=os.getenv("OPENAI_API_KEY"))

# Create vector store
vector_store = Chroma.from_documents(texts, embeddings, persist_directory="./cloud_kb")

# Create retrieval chain
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

def enhance_with_knowledge_base(query):
    """Enhance a query with relevant information from the knowledge base."""
    # Get relevant documents
    docs = retriever.get_relevant_documents(query)
    
    # Format as context
    context = "\n\n".join([f"Document {i+1}:\n{doc.page_content}" for i, doc in enumerate(docs)])
    
    # Create enhanced prompt
    enhanced_prompt = f"""
    Answer the following question about cloud technologies. 
    Use the context provided if relevant, but you don't need to use it if you already know the answer.
    
    Context:
    {context}
    
    Question: {query}
    """
    
    return enhanced_prompt

# AWS Security Configuration
aws:
  lambda:
    # Use IAM roles with least privilege
    execution_role:
      managed_policies:
        - AWSLambdaBasicExecutionRole
      inline_policies:
        - Effect: Allow
          Action:
            - dynamodb:Query
            - dynamodb:PutItem
          Resource: arn:aws:dynamodb:*:*:table/WordUpBotConversations
    
    # Configure VPC if needed
    vpc_config:
      enabled: true
      security_groups:
        - sg-12345678
      subnets:
        - subnet-12345678
        - subnet-87654321
  
  api_gateway:
    # Enable WAF
    waf:
      enabled: true
      rules:
        - name: RateBasedRule
          priority: 1
          rate_limit: 100
    
    # Use API keys for authentication
    api_key_required: true
    
    # Enable logging
    logging:
      enabled: true
      log_level: ERROR

# GCP Security Configuration
gcp:
  cloud_functions:
    # Use service accounts with minimal permissions
    service_account: [email protected]
    
    # Set ingress settings
    ingress_settings: ALLOW_INTERNAL_ONLY
    
    # Enable VPC connector
    vpc_connector: projects/project-id/locations/region/connectors/connector-name
  
  firestore:
    # Set up security rules
    rules: |
      rules_version = '2';
      service cloud.firestore {
        match /databases/{database}/documents {
          match /conversations/{document=**} {
            allow read, write: if false;  // Only backend access
          }
        }
      }

# Azure Security Configuration
azure:
  functions:
    # Authentication settings
    auth:
      enabled: true
      auth_level: function
    
    # Network restrictions
    network:
      ip_security_restrictions:
        - ip_address: 1.2.3.4/32
          action: Allow
    
    # Use managed identity
    identity:
      type: SystemAssigned
      
  table_storage:
    # Enable encryption
    encryption:
      services:
        table:
          enabled: true
      key_type: Account