Tutorials

import vincony

client = vincony.Client(api_key="YOUR_KEY")

buggy = """
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) / 2  # Bug: should be //
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)
"""

fix = client.debug(code=buggy, model="codestral", auto_fix=True)
print(fix.explanation)
print(fix.fixed_code)

# Multi-model refactoring with Vincony
result = client.code.refactor(
    code=legacy_code,
    models=["codestral", "qwen3-coder", "claude-sonnet"],
    style_guide="pep8",
    consensus=True
)

for suggestion in result.suggestions:
    print(f"[{suggestion.model}] {suggestion.change}")

# Generate a complete FastAPI app
app = client.code.generate(
    prompt="FastAPI CRUD for user management with JWT auth",
    framework="fastapi",
    include_tests=True,
    include_docs=True
)

# Auto-generate OpenAPI docs
docs = client.docs.generate(
    source=app.code,
    format="openapi-3.1"
)

# Generate tests for any Python module
tests = client.code.generate_tests(
    source_file="src/payment_processor.py",
    framework="pytest",
    coverage_target=95,
    include_edge_cases=True,
    mock_externals=True
)

print(f"Generated {tests.count} test cases")
print(f"Estimated coverage: {tests.estimated_coverage}%")
tests.save("tests/test_payment_processor.py")

# AI-assisted schema design
schema = client.code.generate(
    prompt="""
    E-commerce platform with:
    - Users with addresses
    - Products with categories and variants
    - Orders with line items and payments
    - Inventory tracking
    """,
    output="postgresql",
    include_indexes=True,
    include_migrations=True
)

print(schema.sql)
print(f"Tables: {len(schema.tables)}")

# Generate commit messages from staged changes
import subprocess

diff = subprocess.check_output(["git", "diff", "--staged"])

message = client.code.generate(
    prompt="Write a conventional commit message for this diff",
    context=diff.decode(),
    format="conventional-commit",
    max_length=72
)

print(message.result)
# feat(auth): add JWT refresh token rotation with Redis storage

# Translate Python to TypeScript
result = client.code.translate(
    source_code=python_module,
    source_lang="python",
    target_lang="typescript",
    preserve_types=True,
    add_jsdoc=True,
    consensus=True  # Multi-model for accuracy
)

print(result.translated_code)
print(f"Confidence: {result.confidence}%")
print(f"Manual review needed: {result.review_needed}")

# Full SEO blog pipeline
pipeline = client.content.blog_pipeline(
    topic="AI-powered code review tools in 2026",
    target_keywords=["AI code review", "automated code review"],
    word_count=2000,
    tone="professional",
    steps=["keyword_research", "outline", "draft", "seo_optimize"]
)

print(f"Title: {pipeline.title}")
print(f"Meta: {pipeline.meta_description}")
print(f"SEO Score: {pipeline.seo_score}/100")
pipeline.save("blog-post.md")

# Generate a 5-email nurture sequence
sequence = client.content.email_sequence(
    product="SaaS analytics platform",
    audience="Marketing managers",
    goal="free_trial_signup",
    emails=5,
    include_ab_variants=True
)

for email in sequence.emails:
    print(f"Day {email.send_day}: {email.subject_a}")
    print(f"  Alt: {email.subject_b}")
    print(f"  Preview: {email.body[:100]}...")

# Generate docs from source code
docs = client.docs.generate(
    source_dir="./src",
    include_patterns=["*.py", "*.ts"],
    output_format="markdown",
    sections=["overview", "api_reference", "examples", "changelog"],
    style="readthedocs"
)

print(f"Generated {len(docs.pages)} documentation pages")
docs.save("./docs/")
docs.generate_sidebar("./docs/_sidebar.md")

# Repurpose a blog post into multiple formats
formats = client.content.repurpose(
    source="./blog-post.md",
    outputs=[
        "twitter_thread",
        "linkedin_post",
        "email_newsletter",
        "video_script",
        "podcast_outline",
        "instagram_carousel"
    ],
    tone="conversational",
    brand_voice="innovative and approachable"
)

for fmt in formats.results:
    print(f"--- {fmt.format} ---")
    print(fmt.content[:200])

# Cross-reference claims across models
result = client.consensus.fact_check(
    text="""
    Python 3.12 introduced pattern matching,
    and React 19 removed the virtual DOM entirely.
    """,
    models=["gpt-5", "claude-opus", "gemini-3"],
    check_sources=True
)

for claim in result.claims:
    print(f"Claim: {claim.text}")
    print(f"Verdict: {claim.verdict}")  # true/false/uncertain
    print(f"Confidence: {claim.confidence}%")
    print(f"Sources: {claim.sources}")

# A/B test prompts across models
experiment = client.prompts.ab_test(
    variants=[
        "Summarize this article in 3 bullet points",
        "Extract the 3 most important takeaways from this article",
        "What are the key insights from this article? List 3.",
    ],
    models=["gpt-5", "claude-opus", "gemini-3"],
    input_text=article,
    metrics=["relevance", "conciseness", "accuracy"],
    runs_per_variant=5
)

print(f"Winner: Variant {experiment.winner.variant_id}")
print(f"Best model: {experiment.winner.model}")
print(f"Score: {experiment.winner.avg_score}/10")

# Audit AI-generated content for hallucinations
audit = client.consensus.hallucination_audit(
    content=ai_generated_article,
    checks=[
        "factual_accuracy",
        "citation_verification",
        "statistical_validity",
        "date_consistency",
        "entity_existence"
    ],
    models=["gpt-5", "claude-opus", "gemini-3"],
    severity_threshold="medium"
)

print(f"Issues found: {audit.total_issues}")
for issue in audit.issues:
    print(f"[{issue.severity}] {issue.description}")
    print(f"  Suggestion: {issue.fix}")

# Start a multi-model debate
debate = client.consensus.debate(
    topic="Is microservices architecture always better than monoliths?",
    models=["gpt-5", "claude-opus", "gemini-3"],
    rounds=3,
    judge_model="claude-opus",
    format="structured"
)

for round in debate.rounds:
    print(f"=== Round {round.number} ===")
    for arg in round.arguments:
        print(f"[{arg.model}]: {arg.position[:150]}...")

print(f"Winner: {debate.verdict.winner}")
print(f"Reasoning: {debate.verdict.explanation}")

# Generate images with multiple models
images = client.image.generate(
    prompt="Modern SaaS dashboard UI, dark theme, glassmorphism",
    models=["flux-pro", "dall-e-3", "stable-diffusion-xl"],
    size="1024x1024",
    quality="hd",
    variations=3
)

for img in images.results:
    print(f"Model: {img.model}")
    print(f"URL: {img.url}")
    img.save(f"output/{img.model}.png")

# Pick the best one
best = images.compare(metric="aesthetic_score")
print(f"Best: {best.model} (score: {best.score})")

# Generate narration from text
audio = client.voice.generate(
    text=blog_post_content,
    voice="aria",  # Natural female voice
    model="elevenlabs-v3",
    speed=1.0,
    format="mp3",
    quality="studio",
    add_pauses=True  # Smart pauses at paragraphs
)

audio.save("podcast-episode.mp3")
print(f"Duration: {audio.duration_seconds}s")
print(f"Word count: {audio.word_count}")

# Generate in multiple languages
for lang in ["es", "fr", "de", "ja"]:
    dubbed = client.voice.dub(audio, target_lang=lang)
    dubbed.save(f"podcast-{lang}.mp3")

# Generate video from text prompt
video = client.video.generate(
    prompt="Product demo: A developer opens a code editor, "
           "pastes buggy code, clicks 'Debug with AI', and "
           "watches as bugs are highlighted and fixed in real-time",
    model="veo-3",
    duration=15,  # seconds
    resolution="1080p",
    aspect_ratio="16:9",
    style="cinematic"
)

video.save("product-demo.mp4")
print(f"Duration: {video.duration}s")

# Add AI voiceover
final = client.video.add_narration(
    video=video,
    script="Watch how AI finds and fixes bugs instantly...",
    voice="professional-male"
)
final.save("demo-with-voiceover.mp4")

# Smart Router auto-selects optimal model
result = client.code.complete(
    prompt="Optimize this SQL query",
    code=slow_query,
    router="smart",  # Auto-routes to best model
    budget="balanced" # cost vs quality tradeoff
)

print(f"Model used: {result.model}")
print(f"Cost: {result.usage.cost}")
print(f"Router reasoning: {result.router_decision}")

# Configure BYOK (Bring Your Own Key)
client = vincony.Client(
    api_key="YOUR_VINCONY_KEY",
    provider_keys={
        "openai": "sk-...",
        "anthropic": "sk-ant-...",
        "google": "AIza...",
    },
    billing_mode="byok"  # Use your own keys
)

# All features work — routed through your keys
result = client.chat.complete(
    model="gpt-5",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(f"Cost: $0.00 (billed to your OpenAI account)")

# Batch process 1000 files
import glob

files = glob.glob("src/**/*.py", recursive=True)

batch = client.batch.create(
    tasks=[
        {"type": "code_review", "file": f, "model": "auto"}
        for f in files
    ],
    concurrency=50,
    retry_policy={"max_retries": 3, "backoff": "exponential"},
    on_progress=lambda p: print(f"Progress: {p.completed}/{p.total}")
)

results = batch.wait()
print(f"Completed: {results.succeeded}/{results.total}")
print(f"Total cost: ${results.total_cost:.2f}")
results.save_report("batch-review-report.json")

# Run SEO audit on your site
audit = client.seo.audit(
    url="https://example.com",
    checks=[
        "core_web_vitals",
        "meta_tags",
        "heading_structure",
        "internal_links",
        "mobile_usability",
        "schema_markup"
    ]
)

print(f"SEO Score: {audit.score}/100")
for issue in audit.critical_issues:
    print(f"[CRITICAL] {issue.description}")
    print(f"  Fix: {issue.recommendation}")

# Keyword research
keywords = client.seo.keyword_research(
    seed="AI code review tools",
    limit=50,
    include_metrics=True
)
for kw in keywords[:10]:
    print(f"{kw.keyword} — Vol: {kw.volume} — Diff: {kw.difficulty}")

# Search with AI + real-time web data
result = client.search.query(
    question="What are the best AI code review tools in 2026?",
    model="sonar-pro",
    include_citations=True,
    max_sources=10,
    recency="last_30_days"
)

print(result.answer)
print(f"\nSources ({len(result.citations)}):")
for cite in result.citations:
    print(f"  [{cite.index}] {cite.title}")
    print(f"      {cite.url}")

# Deep research mode
report = client.search.deep_research(
    question="Compare pricing models of AI coding assistants",
    depth=3,  # Sub-query depth
    format="report"
)
report.save("research-report.md")

# Generate CI/CD pipeline from description
pipeline = client.code.generate(
    prompt="""
    Node.js app with:
    - Lint and test on every PR
    - Build Docker image on main
    - Deploy to AWS ECS staging on main
    - Manual approval for production deploy
    """,
    output="github-actions",
    include_secrets_setup=True
)

print(pipeline.yaml)
pipeline.save(".github/workflows/deploy.yml")

# Generate Docker + K8s configs
configs = client.code.generate(
    prompt="Python FastAPI app with Redis cache and PostgreSQL",
    outputs=["dockerfile", "docker-compose", "k8s-manifests"],
    optimize_for="production",
    include_health_checks=True,
    include_resource_limits=True
)

configs.save("./infra/")
print(f"Generated: {[f.name for f in configs.files]}")

# Multi-model security scan
scan = client.code.security_scan(
    source_dir="./src",
    models=["codestral", "claude-opus", "gpt-5"],
    checks=["sql_injection", "xss", "csrf",
            "path_traversal", "secrets_exposure"],
    consensus=True,
    severity_threshold="medium"
)

for vuln in scan.vulnerabilities:
    print(f"[{vuln.severity}] {vuln.file}:{vuln.line}")
    print(f"  {vuln.description}")
    print(f"  Fix: {vuln.recommendation}")

# Generate tailored resume + cover letter
application = client.content.job_application(
    resume_data={
        "experience": experience_list,
        "skills": skills_list,
        "education": education_list
    },
    job_description=job_posting_text,
    optimize_for="ats",
    tone="professional",
    outputs=["resume_pdf", "cover_letter", "linkedin_summary"]
)

print(f"ATS Score: {application.ats_score}/100")
print(f"Keyword Match: {application.keyword_match}%")
application.save("./applications/")

# Generate social media threads
threads = client.content.generate_threads(
    topic="Why AI code review catches 3x more bugs",
    platforms=["twitter", "linkedin"],
    style="thought_leadership",
    include_hooks=True,
    include_cta=True,
    thread_length=8  # tweets/slides
)

for platform in threads.results:
    print(f"--- {platform.name} ---")
    for i, post in enumerate(platform.posts):
        print(f"{i+1}. {post.text[:100]}...")
    print(f"Best time to post: {platform.optimal_time}")

# Batch product descriptions
descriptions = client.content.product_descriptions(
    products=[
        {"name": "Wireless Earbuds Pro", "specs": specs_dict},
        {"name": "Smart Watch Ultra", "specs": specs_dict_2},
    ],
    tone="premium",
    seo_keywords=True,
    include_ab_variants=True,
    platforms=["shopify", "amazon", "website"]
)

for desc in descriptions.results:
    print(f"{desc.product}: {desc.title}")
    print(f"  SEO Score: {desc.seo_score}/100")

# Compare contract clause interpretations
analysis = client.consensus.analyze_clause(
    clause=contract_clause_text,
    models=["gpt-5", "claude-opus", "gemini-3"],
    checks=["risk_level", "obligations",
            "ambiguity", "enforceability"],
    jurisdiction="US",
    consensus=True
)

print(f"Risk Level: {analysis.consensus_risk}")
print(f"Agreement: {analysis.model_agreement}%")
for model in analysis.interpretations:
    print(f"[{model.name}] {model.summary}")

# Validate data transformations
validation = client.consensus.validate_data(
    input_data="sales_raw.csv",
    output_data="sales_cleaned.csv",
    transformations=[
        "Remove duplicates",
        "Normalize phone numbers",
        "Convert currencies to USD"
    ],
    models=["gpt-5", "claude-opus", "gemini-3"],
    sample_size=100
)

print(f"Accuracy: {validation.accuracy}%")
for issue in validation.issues:
    print(f"Row {issue.row}: {issue.description}")

# Generate a complete brand kit
brand = client.media.generate_brand_kit(
    brand_name="TechFlow",
    industry="SaaS / Developer Tools",
    style=["minimalist", "modern", "tech"],
    colors=["blue", "dark"],
    logo_concepts=6,
    include=["logo_svg", "color_palette",
             "typography", "social_templates",
             "favicon", "brand_guidelines"]
)

print(f"Generated {len(brand.logos)} logo concepts")
brand.download_all("./brand-assets/")

# Full podcast pipeline
episode = client.media.generate_podcast(
    title="AI in Production: Lessons Learned",
    format="two_host_discussion",
    topics=["Deployment challenges", "Monitoring AI",
            "Cost optimization strategies"],
    duration_minutes=20,
    hosts=[
        {"name": "Alex", "voice": "professional_male"},
        {"name": "Sam", "voice": "warm_female"}
    ],
    include_intro_music=True,
    include_chapters=True
)

episode.download("ai-production-ep1.mp3")
print(f"Duration: {episode.duration}")

# Generate a presentation deck
deck = client.media.generate_presentation(
    topic="Q4 2026 Product Roadmap",
    audience="Engineering team",
    slides=15,
    style="modern-dark",
    include=["speaker_notes", "diagrams",
             "charts", "transition_animations"],
    data_sources=["roadmap.md", "metrics.csv"]
)

deck.export("roadmap-deck.pptx")
deck.export("roadmap-deck.pdf")
print(f"Generated {len(deck.slides)} slides")

# Analyze and optimize token spending
analysis = client.platform.optimize_budget(
    usage_period="last_30_days",
    optimization_goals=["reduce_cost"],
    quality_threshold=0.9,
    suggest_model_swaps=True,
    suggest_prompt_compression=True
)

print(f"Current spend: ${analysis.current_cost:.2f}/mo")
print(f"Optimized spend: ${analysis.projected_cost:.2f}/mo")
print(f"Savings: {analysis.savings_percent}%")
for rec in analysis.recommendations:
    print(f"  → {rec.description}")

# Set up model A/B test
experiment = client.platform.ab_test(
    name="GPT-5 vs Claude Opus for support",
    control_model="gpt-4o",
    treatment_model="gpt-5",
    traffic_split=0.1,
    metrics=["response_quality", "latency",
             "cost_per_request", "user_satisfaction"],
    duration_days=7,
    auto_rollout=True,
    rollback_threshold=0.05
)

print(f"Experiment: {experiment.id}")
print(f"Status: {experiment.status}")

# Generate webhook handler
handler = client.code.generate_webhook(
    provider="stripe",
    events=["checkout.session.completed"],
    actions={"checkout.session.completed": "Provision account"},
    framework="fastapi",
    include_signature_verification=True
)
print(handler.code)

# Train brand voice profile
voice = client.content.train_voice(
    name="My Brand Voice",
    samples=["post1.md", "post2.md", "emails.csv"],
    analyze=["tone", "vocabulary", "sentence_structure"]
)

article = client.content.write(
    topic="Product launch announcement",
    voice_profile=voice.id,
    word_count=800
)
print(f"Voice match: {article.voice_match_score}%")

# Generate ETL pipeline
pipeline = client.code.generate_pipeline(
    description="""
    Extract: PostgreSQL orders (daily)
    Transform: Join customers, calc LTV
    Load: BigQuery analytics
    """,
    framework="airflow",
    include_data_quality_checks=True
)
pipeline.save("dags/orders_etl.py")

# Convert Python to Rust
converted = client.code.convert(
    source_code=open("processor.py").read(),
    source_language="python",
    target_language="rust",
    use_idiomatic_patterns=True,
    consensus=True
)
print(f"Confidence: {converted.confidence}%")
converted.save("src/processor.rs")

# Generate wireframe and convert to code
wireframe = client.media.generate_wireframe(
    description="Dashboard with sidebar, metric cards, chart",
    style="clean_modern",
    resolution="1440x900"
)

code = client.code.wireframe_to_react(
    wireframe=wireframe,
    framework="react",
    styling="tailwind",
    component_library="shadcn"
)
code.save("src/components/Dashboard.tsx")

# Generate privacy policy
policy = client.legal.generate_privacy_policy(
    business_name="MyApp Inc.",
    data_collected=["email", "analytics", "payments"],
    third_party_services=["Stripe", "Google Analytics"],
    jurisdictions=["GDPR", "CCPA"]
)
print(f"Compliance: {policy.compliance_score}%")
policy.export("privacy-policy.html")

# Generate spreadsheet formula
formula = client.tools.spreadsheet_formula(
    description="Weighted average of B2:B100 by C2:C100 "
                "where column A is 'Active'",
    platform="google_sheets",
    explain=True
)
print(f"Formula: {formula.result}")
print(f"Explanation: {formula.explanation}")

# Analyze A/B test results
analysis = client.consensus.analyze_ab_test(
    data="ab_results.csv",
    metric="conversion_rate",
    segments=["device", "country"],
    models=["gpt-5", "claude-opus", "gemini-3"]
)
print(f"Winner: {analysis.winner}")
print(f"Lift: {analysis.lift}%")
print(f"Confidence: {analysis.confidence}%")

# Analyze competitor content gaps
gaps = client.seo.content_gap_analysis(
    your_domain="example.com",
    competitors=["competitor1.com", "competitor2.com"],
    include_metrics=True,
    generate_briefs=True
)

print(f"Found {len(gaps.opportunities)} content gaps")
for gap in gaps.opportunities[:10]:
    print(f"Keyword: {gap.keyword}")
    print(f"  Volume: {gap.monthly_volume}")
    print(f"  Difficulty: {gap.difficulty}/100")
    print(f"  Brief: {gap.content_brief[:100]}...")

# Build a support bot from docs
bot = client.platform.create_support_bot(
    name="TechFlow Support",
    knowledge_sources=[
        "./docs/",
        "./faq.md",
        "https://docs.example.com"
    ],
    model="gpt-5",
    escalation_rules={
        "billing": "[email protected]",
        "bugs": "[email protected]"
    },
    tone="friendly_professional",
    languages=["en", "es", "fr"]
)

print(f"Bot ID: {bot.id}")
print(f"Knowledge articles: {bot.article_count}")
print(f"Embed: {bot.embed_script}")