Conditional Text Generation with OpenAI: Tailoring Technical Outputs

Copy codepip install openai python-dotenv

Copy codeOPENAI_API_KEY=sk-abc123xyz

Copy codeimport openai
from dotenv import load_dotenv
import os

# Load API key
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Conditioned prompt
prompt = "Explain vector databases in a formal, technical manner."
response = openai.Completion.create(
    model="text-davinci-003",
    prompt=prompt,
    max_tokens=100,
    temperature=0.5
)

# Display output
text = response.choices[0].text.strip()
print("Formal Technical Explanation:")
print(text)

Copy codeFormal Technical Explanation:
Vector databases are repositories designed to store data as high-dimensional vectors. They facilitate efficient similarity searches through metrics such as cosine distance. Employing indexing methodologies, for instance HNSW, they ensure rapid data retrieval. These systems support advanced AI applications, including semantic search and recommendation engines, by embedding data with transformer models to maintain semantic integrity.

Copy codeimport openai
from dotenv import load_dotenv
import os

# Load API key
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Conditioned prompt for technical doc
prompt = "Write a formal, technical description of vector databases for a documentation manual, limited to 100 words."
response = openai.Completion.create(
    model="text-davinci-003",
    prompt=prompt,
    max_tokens=150,
    temperature=0.5
)

# Save output
text = response.choices[0].text.strip()
with open("vector_db_doc.txt", "w") as file:
    file.write(text)

# Display
print("Technical Doc Generated:")
print(text)
print(f"Word count: {len(text.split())}")

Copy codeTechnical Doc Generated:
Vector databases constitute specialized repositories engineered to store data as high-dimensional vectors, facilitating efficient similarity searches via cosine distance metrics. They employ sophisticated indexing techniques, such as Hierarchical Navigable Small World (HNSW), to enable rapid retrieval. These systems underpin advanced artificial intelligence applications, including semantic search and recommendation frameworks, by embedding data with transformer models. This preserves semantic relationships, ensuring precise and scalable data management within technical infrastructures.
Word count: 98

Copy codeimport openai
from dotenv import load_dotenv
import os

# Load API key
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Conditioned prompt
prompt = "Write a formal, technical description of vector databases for a documentation manual, limited to 100 words."
response = openai.Completion.create(
    model="text-davinci-003",
    prompt=prompt,
    max_tokens=150,
    temperature=0.5
)
formal_text = response.choices[0].text.strip()

# Test adherence manually (simplified check)
print("Testing Condition Adherence:")
print("Formal Output:")
print(formal_text)
print(f"Word count: {len(formal_text.split())}")
print("Look for: Formal tone (e.g., no slang), technical terms (e.g., 'indexing'), clear structure.")

Copy codeTesting Condition Adherence:
Formal Output:
Vector databases constitute specialized repositories engineered to store data as high-dimensional vectors, facilitating efficient similarity searches via cosine distance metrics. They employ sophisticated indexing techniques, such as Hierarchical Navigable Small World (HNSW), to enable rapid retrieval. These systems underpin advanced artificial intelligence applications, including semantic search and recommendation frameworks, by embedding data with transformer models. This preserves semantic relationships, ensuring precise and scalable data management within technical infrastructures.
Word count: 98
Look for: Formal tone (e.g., no slang), technical terms (e.g., 'indexing'), clear structure.

Copy codepip install weaviate-client

Copy codeimport openai
import weaviate
from dotenv import load_dotenv
import os

# Load API keys
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Generate conditioned text
prompt = "Write a formal, technical description of vector databases for a documentation manual, limited to 100 words."
response = openai.Completion.create(
    model="text-davinci-003",
    prompt=prompt,
    max_tokens=150,
    temperature=0.5
)
formal_text = response.choices[0].text.strip()

# Connect to Weaviate (local instance example)
client = weaviate.Client("http://localhost:8080")  # Adjust if using cloud

# Define schema (run once)
schema = {
    "classes": [{
        "class": "TechDoc",
        "properties": [
            {"name": "text", "dataType": ["text"]},
            {"name": "condition", "dataType": ["string"]},
            {"name": "source", "dataType": ["string"]}
        ],
        "vectorizer": "none"  # Using precomputed vectors
    }]
}
if not client.schema.contains(schema):
    client.schema.create(schema)

# Generate embedding
embedding_response = openai.Embedding.create(model="text-embedding-ada-002", input=formal_text)
vector = embedding_response["data"][0]["embedding"]

# Store in Weaviate
client.data_object.create(
    data_object={
        "text": formal_text,
        "condition": "formal",
        "source": "manual"
    },
    class_name="TechDoc",
    vector=vector
)

# Confirm storage
print("Stored in Weaviate:")
print(f"Text: {formal_text[:50]}...")
print("Metadata: {'condition': 'formal', 'source': 'manual'}")

Copy codeStored in Weaviate:
Text: Vector databases constitute specialized repositories...
Metadata: {'condition': 'formal', 'source': 'manual'}

Copy codeimport openai
import weaviate
from dotenv import load_dotenv
import os

# Load API keys
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Conditioned prompt
formal_prompt = "Write a formal, technical description of vector databases for a documentation manual, limited to 100 words."
formal_response = openai.Completion.create(
    model="text-davinci-003",
    prompt=formal_prompt,
    max_tokens=150,
    temperature=0.5
)
formal_text = formal_response.choices[0].text.strip()

# Free-form prompt
free_prompt = "Explain vector databases."
free_response = openai.Completion.create(
    model="text-davinci-003",
    prompt=free_prompt,
    max_tokens=150,
    temperature=0.7
)
free_text = free_response.choices[0].text.strip()

# Display comparison
print("Conditioned (Formal) Output:")
print(formal_text)
print(f"Word count: {len(formal_text.split())}")
print("\nFree-Form Output:")
print(free_text)
print(f"Word count: {len(free_text.split())}")

Copy codeConditioned (Formal) Output:
Vector databases constitute specialized repositories engineered to store data as high-dimensional vectors, facilitating efficient similarity searches via cosine distance metrics. They employ sophisticated indexing techniques, such as Hierarchical Navigable Small World (HNSW), to enable rapid retrieval. These systems underpin advanced artificial intelligence applications, including semantic search and recommendation frameworks, by embedding data with transformer models. This preserves semantic relationships, ensuring precise and scalable data management within technical infrastructures.
Word count: 98

Free-Form Output:
Vector databases are cool tools that keep data as vectors, making it easy to find similar stuff fast with things like cosine distance. They use tricks like HNSW indexing to speed things up. Great for AI stuff, like search or suggestions, they turn data into vectors with transformers and keep meanings clear.
Word count: 107