OpenAI with guardrail backend

pip install fastapi
pip install "uvicorn[standard]"

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
@app.get("/helloworld")
async def helloworld():
    return {"message": "Hello World"}

pip install openai
pip install uuid
pip install pydantic
pip install langchain

def add_rule(text):
    Chroma.from_texts(collection_name=collection_name,texts=[text], embedding=embedding ,persist_directory=persist_dir)

@app.post('/create_rule')
def create_rule(rule:Rule):
    add_rule(rule.rule)
    return JSONResponse(content={
        "message":"success",
        "rule":rule.rule
        })

def get_collection():
    vectorstore = init_db()
    result = vectorstore.get()
    return result['documents']
@app.get('/rule')
def get_rule():
    res = get_collection()
    return JSONResponse(content={"result":res})

def clear_db_collection():
    vectorstore = init_db()
    res = vectorstore.delete_collection()
@app.get('/clear_collection')
def clear_collection():
    clear_db_collection()
    return JSONResponse(content={"message":"remove complete"})

@app.get("/session")
def session():
    client_uuid = uuid.uuid4()
    create_session(str(client_uuid))
    result = {
        "uuid" : str(client_uuid)
    }
    return JSONResponse(content=result)

@app.get("/query")
async def main(uuid:str,message:str):
    get_session(uuid)
    collection = get_collection()
    if  len(collection) == 0:
        return StreamingResponse(
                    generate_response('No rules configure please ask admin'), 
                    media_type="text/event-stream"
                )
    else:
        score = compare_similarity(message)
        print(score)
        if score > 0.7:
            return StreamingResponse(
                        stream_chat(
                            uuid = uuid,
                            prompt= message
                        ), 
                        media_type="text/event-stream"
                    )
        else:
            return StreamingResponse(
                        generate_response('bad prompt please ask another one'), 
                        media_type="text/event-stream"
                    )

from langchain.embeddings import OpenAIEmbeddings
api_key = 'sk-XcTnjgYVsJQMNxxxxxxxxxxxxxx'
embedding=OpenAIEmbeddings(openai_api_key=api_key)

import openai
openai.api_key = api_key
def stream_chat(uuid:str,prompt: str):
    result = ""
    messages = add_message(uuid,'user',prompt)
    for chunk in openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=messages,
        stream=True,
    ):
        content = chunk["choices"][0].get("delta", {}).get("content")
        if content is not None:
            result = result + content
            yield content
    add_message(uuid,'assistant',result)

from langchain.vectorstores import Chroma
def init_db():
    vectorstore = Chroma(collection_name=collection_name,persist_directory=persist_dir,embedding_function=embedding)
    return vectorstore

def compare_similarity(query):
    vectorstore = init_db()
    result = vectorstore.similarity_search_with_relevance_scores(query, k=5)
    score_list = []
    for i in result:
        score_list.append(i[-1])
    try:
        average = sum(score_list)/len(score_list)
        return average
    except:
        return 0

screen -S name

cd path/to/api

uvicorn guardrail:app --host 0.0.0.0 --port 8000

Ctrl+a d

from fastapi.middleware.cors import CORSMiddleware
app.app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

get:/rule
reponse: {
    "result": [
        "Macbook",
        "Apple",
        "Apple is a technology company not a fruit"
    ]
}

post: /create_rule
body: {rule: "new rule"}
response: {message: "success", rule: "new rule"}

get: /clear_collection
response: {"message":"remove complete"}