Chat Agent

from langchain_anthropic import ChatAnthropic
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

async def initialize_agent():
    # Initialize Claude LLM
    llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
    
    # Load character configuration
    characters = loadCharacters(os.getenv("CHARACTER_FILE"))
    character = characters[0]
    personality = process_character_config(character)
    
    # Create tools (blockchain, Twitter, search, etc.)
    tools = create_agent_tools(llm, knowledge_base, podcast_knowledge_base, agent_kit, config)
    
    # Initialize memory for conversation history
    memory = MemorySaver()
    
    # Create ReAct agent with personality
    agent = create_react_agent(
        llm,
        tools=tools,
        checkpointer=memory,
        state_modifier=personality,
    )
    
    return agent, config, runnable_config

async def run_chat_mode(agent_executor, config, runnable_config):
    print_system("Starting chat mode... Type 'exit' to end.")
    print_system("Commands:")
    print_system("  exit     - Exit the chat")
    print_system("  status   - Check if agent is responsive")
    
    # Create the runnable config with required keys
    runnable_config = RunnableConfig(
        recursion_limit=200,
        configurable={
            "thread_id": config["configurable"]["thread_id"],
            "langgraph_checkpoint_ns": "chat_mode",
            "langgraph_checkpoint_id": config["configurable"]["langgraph_checkpoint_id"]
        }
    )
    
    while True:
        try:
            user_input = input("User: ")
            
            if user_input.lower() == "exit":
                break
            elif user_input.lower() == "status":
                print_system("Agent is responsive and ready for commands.")
                continue
            
            # Stream agent responses
            async for chunk in agent_executor.astream(
                {"messages": [HumanMessage(content=user_input)]},
                runnable_config
            ):
                if "agent" in chunk:
                    response = chunk["agent"]["messages"][0].content
                    print_ai(format_ai_message_content(response))
                elif "tools" in chunk:
                    print_system(chunk["tools"]["messages"][0].content)
                    
        except KeyboardInterrupt:
            print_system("\nExiting chat mode...")
            break

{
  "name": "your name",
  "accountid": "123456789",
  "modelProvider": "anthropic",
  "bio": [
    "Core contributor at hadron founders club",
    "Advisor to @0xPolygon",
    "Angel investor focusing on strong product and engineering founders"
  ],
  "lore": [
    "Believes that blockchains will change how financial systems work",
    "Advocates for liquid and efficient private markets through tokenization"
  ],
  "knowledge": [
    "Deep understanding of blockchain technology and its implications",
    "Expertise in decentralized finance (DeFi) and its mechanisms"
  ],
  "adjectives": [
    "funny",
    "intelligent",
    "academic",
    "insightful"
  ],
  "topics": [
    "defi",
    "ethereum",
    "zk_rollups",
    "solana"
  ],
  "style": {
    "all": [
      "uses short punchy one-liners",
      "favors concise, single-sentence responses",
      "employs strategic brevity",
      "maintains builder credibility while staying humble"
    ]
  }
}

# LLM Provider (Required)
ANTHROPIC_API_KEY=your_anthropic_api_key

# Character Configuration
CHARACTER_FILE=characters/default.json

# Knowledge Bases
USE_TWITTER_KNOWLEDGE_BASE=false
USE_PODCAST_KNOWLEDGE_BASE=true

# Tool Toggles
USE_COINBASE_TOOLS=true
USE_HYPERBOLIC_TOOLS=true
USE_BROWSER_TOOLS=true
USE_WEB_SEARCH=true
USE_WRITING_AGENT=true

# Twitter Integration (Optional)
USE_TWITTER_CORE=true
TWITTER_API_KEY=your_twitter_api_key
TWITTER_API_SECRET=your_twitter_api_secret

python chatbot.py

async def run_with_progress(func, *args, **kwargs):
    progress = ProgressIndicator()
    
    try:
        generator = func(*args, **kwargs)
        
        async for chunk in generator:
            progress.stop()  # Stop spinner before output
            yield chunk
            progress.start()  # Restart spinner while waiting
    finally:
        progress.stop()

# Each agent has a unique thread ID for conversation history
config = {
    "configurable": {
        "thread_id": f"{character['name']} Agent",
        "checkpoint_id": str(uuid.uuid4())
    }
}

# Memory is persisted across messages in the same session
memory = MemorySaver()
agent = create_react_agent(llm, tools=tools, checkpointer=memory)